blockly 8.0.4 → 8.0.5-beta.0

package/core/bubble_dragger.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { IBubble } from './interfaces/i_bubble.js';
+import { Coordinate } from './utils/coordinate.js';
+import type { WorkspaceSvg } from './workspace_svg.js';
+/**
+ * Class for a bubble dragger.  It moves things on the bubble canvas around the
+ * workspace when they are being dragged by a mouse or touch.  These can be
+ * block comments, mutators, warnings, or workspace comments.
+ * @alias Blockly.BubbleDragger
+ */
+export declare class BubbleDragger {
+    private bubble;
+    private workspace;
+    /** Which drag target the mouse pointer is over, if any. */
+    private dragTarget_;
+    /** Whether the bubble would be deleted if dropped immediately. */
+    private wouldDeleteBubble_;
+    private readonly startXY_;
+    private dragSurface_;
+    /**
+     * @param bubble The item on the bubble canvas to drag.
+     * @param workspace The workspace to drag on.
+     */
+    constructor(bubble: IBubble, workspace: WorkspaceSvg);
+    /**
+     * Start dragging a bubble.  This includes moving it to the drag surface.
+     * @internal
+     */
+    startBubbleDrag(): void;
+    /**
+     * Execute a step of bubble dragging, based on the given event.  Update the
+     * display accordingly.
+     * @param e The most recent move event.
+     * @param currentDragDeltaXY How far the pointer has moved from the position
+     *     at the start of the drag, in pixel units.
+     * @internal
+     */
+    dragBubble(e: Event, currentDragDeltaXY: Coordinate): void;
+    /**
+     * Whether ending the drag would delete the bubble.
+     * @param dragTarget The drag target that the bubblee is currently over.
+     * @return Whether dropping the bubble immediately would delete the block.
+     */
+    private shouldDelete_;
+    /**
+     * Update the cursor (and possibly the trash can lid) to reflect whether the
+     * dragging bubble would be deleted if released immediately.
+     */
+    private updateCursorDuringBubbleDrag_;
+    /**
+     * Finish a bubble drag and put the bubble back on the workspace.
+     * @param e The mouseup/touchend event.
+     * @param currentDragDeltaXY How far the pointer has moved from the position
+     *     at the start of the drag, in pixel units.
+     * @internal
+     */
+    endBubbleDrag(e: Event, currentDragDeltaXY: Coordinate): void;
+    /** Fire a move event at the end of a bubble drag. */
+    private fireMoveEvent_;
+    /**
+     * Convert a coordinate object from pixels to workspace units, including a
+     * correction for mutator workspaces.
+     * This function does not consider differing origins.  It simply scales the
+     * input's x and y values.
+     * @param pixelCoord A coordinate with x and y values in CSS pixel units.
+     * @return The input coordinate divided by the workspace scale.
+     */
+    private pixelsToWorkspaceUnits_;
+}

package/core/bubble_dragger.ts

@@ -0,0 +1,229 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Methods for dragging a bubble visually.
+ */
+
+/**
+ * Methods for dragging a bubble visually.
+ * @class
+ */
+import * as goog from '../closure/goog/goog.js';
+goog.declareModuleId('Blockly.BubbleDragger');
+
+// Unused import preserved for side-effects. Remove if unneeded.
+// import './bubble.js';
+// Unused import preserved for side-effects. Remove if unneeded.
+// import './constants.js';
+
+import type {BlockDragSurfaceSvg} from './block_drag_surface.js';
+import {ComponentManager} from './component_manager.js';
+import type {CommentMove} from './events/events_comment_move.js';
+import * as eventUtils from './events/utils.js';
+import type {IBubble} from './interfaces/i_bubble.js';
+import type {IDeleteArea} from './interfaces/i_delete_area.js';
+import type {IDragTarget} from './interfaces/i_drag_target.js';
+import {Coordinate} from './utils/coordinate.js';
+import * as svgMath from './utils/svg_math.js';
+import {WorkspaceCommentSvg} from './workspace_comment_svg.js';
+import type {WorkspaceSvg} from './workspace_svg.js';
+
+
+/**
+ * Class for a bubble dragger.  It moves things on the bubble canvas around the
+ * workspace when they are being dragged by a mouse or touch.  These can be
+ * block comments, mutators, warnings, or workspace comments.
+ * @alias Blockly.BubbleDragger
+ */
+export class BubbleDragger {
+  /** Which drag target the mouse pointer is over, if any. */
+  private dragTarget_: IDragTarget|null = null;
+
+  /** Whether the bubble would be deleted if dropped immediately. */
+  private wouldDeleteBubble_ = false;
+  private readonly startXY_: Coordinate;
+  private dragSurface_: BlockDragSurfaceSvg|null;
+
+  /**
+   * @param bubble The item on the bubble canvas to drag.
+   * @param workspace The workspace to drag on.
+   */
+  constructor(private bubble: IBubble, private workspace: WorkspaceSvg) {
+    /**
+     * The location of the top left corner of the dragging bubble's body at the
+     * beginning of the drag, in workspace coordinates.
+     */
+    this.startXY_ = this.bubble.getRelativeToSurfaceXY();
+
+    /**
+     * The drag surface to move bubbles to during a drag, or null if none should
+     * be used.  Block dragging and bubble dragging use the same surface.
+     */
+    this.dragSurface_ =
+        svgMath.is3dSupported() && !!workspace.getBlockDragSurface() ?
+        workspace.getBlockDragSurface() :
+        null;
+  }
+
+  /**
+   * Start dragging a bubble.  This includes moving it to the drag surface.
+   * @internal
+   */
+  startBubbleDrag() {
+    if (!eventUtils.getGroup()) {
+      eventUtils.setGroup(true);
+    }
+
+    this.workspace.setResizesEnabled(false);
+    this.bubble.setAutoLayout(false);
+    if (this.dragSurface_) {
+      this.bubble.moveTo(0, 0);
+      this.dragSurface_.translateSurface(this.startXY_.x, this.startXY_.y);
+      // Execute the move on the top-level SVG component.
+      this.dragSurface_.setBlocksAndShow(this.bubble.getSvgRoot());
+    }
+
+    this.bubble.setDragging && this.bubble.setDragging(true);
+  }
+
+  /**
+   * Execute a step of bubble dragging, based on the given event.  Update the
+   * display accordingly.
+   * @param e The most recent move event.
+   * @param currentDragDeltaXY How far the pointer has moved from the position
+   *     at the start of the drag, in pixel units.
+   * @internal
+   */
+  dragBubble(e: Event, currentDragDeltaXY: Coordinate) {
+    const delta = this.pixelsToWorkspaceUnits_(currentDragDeltaXY);
+    const newLoc = Coordinate.sum(this.startXY_, delta);
+    this.bubble.moveDuringDrag(this.dragSurface_, newLoc);
+
+    const oldDragTarget = this.dragTarget_;
+    this.dragTarget_ = this.workspace.getDragTarget(e);
+
+    const oldWouldDeleteBubble = this.wouldDeleteBubble_;
+    this.wouldDeleteBubble_ = this.shouldDelete_(this.dragTarget_);
+    if (oldWouldDeleteBubble !== this.wouldDeleteBubble_) {
+      // Prevent unnecessary add/remove class calls.
+      this.updateCursorDuringBubbleDrag_();
+    }
+    // Call drag enter/exit/over after wouldDeleteBlock is called in
+    // shouldDelete_
+    if (this.dragTarget_ !== oldDragTarget) {
+      oldDragTarget && oldDragTarget.onDragExit(this.bubble);
+      this.dragTarget_ && this.dragTarget_.onDragEnter(this.bubble);
+    }
+    this.dragTarget_ && this.dragTarget_.onDragOver(this.bubble);
+  }
+
+  /**
+   * Whether ending the drag would delete the bubble.
+   * @param dragTarget The drag target that the bubblee is currently over.
+   * @return Whether dropping the bubble immediately would delete the block.
+   */
+  private shouldDelete_(dragTarget: IDragTarget|null): boolean {
+    if (dragTarget) {
+      const componentManager = this.workspace.getComponentManager();
+      const isDeleteArea = componentManager.hasCapability(
+          dragTarget.id, ComponentManager.Capability.DELETE_AREA);
+      if (isDeleteArea) {
+        return (dragTarget as IDeleteArea).wouldDelete(this.bubble, false);
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Update the cursor (and possibly the trash can lid) to reflect whether the
+   * dragging bubble would be deleted if released immediately.
+   */
+  private updateCursorDuringBubbleDrag_() {
+    this.bubble.setDeleteStyle(this.wouldDeleteBubble_);
+  }
+
+  /**
+   * Finish a bubble drag and put the bubble back on the workspace.
+   * @param e The mouseup/touchend event.
+   * @param currentDragDeltaXY How far the pointer has moved from the position
+   *     at the start of the drag, in pixel units.
+   * @internal
+   */
+  endBubbleDrag(e: Event, currentDragDeltaXY: Coordinate) {
+    // Make sure internal state is fresh.
+    this.dragBubble(e, currentDragDeltaXY);
+
+    const preventMove =
+        this.dragTarget_ && this.dragTarget_.shouldPreventMove(this.bubble);
+    let newLoc;
+    if (preventMove) {
+      newLoc = this.startXY_;
+    } else {
+      const delta = this.pixelsToWorkspaceUnits_(currentDragDeltaXY);
+      newLoc = Coordinate.sum(this.startXY_, delta);
+    }
+    // Move the bubble to its final location.
+    this.bubble.moveTo(newLoc.x, newLoc.y);
+
+    if (this.dragTarget_) {
+      this.dragTarget_.onDrop(this.bubble);
+    }
+
+    if (this.wouldDeleteBubble_) {
+      // Fire a move event, so we know where to go back to for an undo.
+      this.fireMoveEvent_();
+      this.bubble.dispose();
+    } else {
+      // Put everything back onto the bubble canvas.
+      if (this.dragSurface_) {
+        this.dragSurface_.clearAndHide(this.workspace.getBubbleCanvas());
+      }
+      if (this.bubble.setDragging) {
+        this.bubble.setDragging(false);
+      }
+      this.fireMoveEvent_();
+    }
+    this.workspace.setResizesEnabled(true);
+
+    eventUtils.setGroup(false);
+  }
+
+  /** Fire a move event at the end of a bubble drag. */
+  private fireMoveEvent_() {
+    if (this.bubble instanceof WorkspaceCommentSvg) {
+      const event = new (eventUtils.get(eventUtils.COMMENT_MOVE))!
+          (this.bubble) as CommentMove;
+      event.setOldCoordinate(this.startXY_);
+      event.recordNew();
+      eventUtils.fire(event);
+    }
+    // TODO (fenichel): move events for comments.
+    return;
+  }
+
+  /**
+   * Convert a coordinate object from pixels to workspace units, including a
+   * correction for mutator workspaces.
+   * This function does not consider differing origins.  It simply scales the
+   * input's x and y values.
+   * @param pixelCoord A coordinate with x and y values in CSS pixel units.
+   * @return The input coordinate divided by the workspace scale.
+   */
+  private pixelsToWorkspaceUnits_(pixelCoord: Coordinate): Coordinate {
+    const result = new Coordinate(
+        pixelCoord.x / this.workspace.scale,
+        pixelCoord.y / this.workspace.scale);
+    if (this.workspace.isMutator) {
+      // If we're in a mutator, its scale is always 1, purely because of some
+      // oddities in our rendering optimizations.  The actual scale is the same
+      // as the scale on the parent workspace. Fix that for dragging.
+      const mainScale = this.workspace.options.parentWorkspace!.scale;
+      result.scale(1 / mainScale);
+    }
+    return result;
+  }
+}

package/core/bump_objects.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Abstract } from './events/events_abstract.js';
+import type { IBoundedElement } from './interfaces/i_bounded_element.js';
+import type { ContainerRegion } from './metrics_manager.js';
+import type { WorkspaceSvg } from './workspace_svg.js';
+/**
+ * Bumps the given object that has passed out of bounds.
+ * @param workspace The workspace containing the object.
+ * @param scrollMetrics Scroll metrics
+ *    in workspace coordinates.
+ * @param object The object to bump.
+ * @return True if block was bumped.
+ * @alias Blockly.bumpObjects.bumpIntoBounds
+ */
+declare function bumpObjectIntoBounds(workspace: WorkspaceSvg, scrollMetrics: ContainerRegion, object: IBoundedElement): boolean;
+export declare const bumpIntoBounds: typeof bumpObjectIntoBounds;
+/**
+ * Creates a handler for bumping objects when they cross fixed bounds.
+ * @param workspace The workspace to handle.
+ * @return The event handler.
+ * @alias Blockly.bumpObjects.bumpIntoBoundsHandler
+ */
+export declare function bumpIntoBoundsHandler(workspace: WorkspaceSvg): (p1: Abstract) => void;
+/**
+ * Bumps the top objects in the given workspace into bounds.
+ * @param workspace The workspace.
+ * @alias Blockly.bumpObjects.bumpTopObjectsIntoBounds
+ */
+export declare function bumpTopObjectsIntoBounds(workspace: WorkspaceSvg): void;
+export {};

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

@@ -7,42 +7,41 @@
 /**
  * @fileoverview Utilities for bumping objects back into worksapce bounds.
  */
-'use strict';
 
 /**
  * Utilities for bumping objects back into worksapce bounds.
  * @namespace Blockly.bumpObjects
  */
-goog.module('Blockly.bumpObjects');
-
-const eventUtils = goog.require('Blockly.Events.utils');
-const mathUtils = goog.require('Blockly.utils.math');
-/* eslint-disable-next-line no-unused-vars */
-const {Abstract} = goog.requireType('Blockly.Events.Abstract');
-/* eslint-disable-next-line no-unused-vars */
-const {BlockSvg} = goog.requireType('Blockly.BlockSvg');
-/* eslint-disable-next-line no-unused-vars */
-const {IBoundedElement} = goog.requireType('Blockly.IBoundedElement');
-/* eslint-disable-next-line no-unused-vars */
-const {MetricsManager} = goog.requireType('Blockly.MetricsManager');
-/* eslint-disable-next-line no-unused-vars */
-const {ViewportChange} = goog.requireType('Blockly.Events.ViewportChange');
-/* eslint-disable-next-line no-unused-vars */
-const {WorkspaceCommentSvg} = goog.requireType('Blockly.WorkspaceCommentSvg');
-/* eslint-disable-next-line no-unused-vars */
-const {WorkspaceSvg} = goog.requireType('Blockly.WorkspaceSvg');
+import * as goog from '../closure/goog/goog.js';
+goog.declareModuleId('Blockly.bumpObjects');
+
+import type {BlockSvg} from './block_svg.js';
+import type {Abstract} from './events/events_abstract.js';
+import type {BlockCreate} from './events/events_block_create.js';
+import type {BlockMove} from './events/events_block_move.js';
+import type {CommentCreate} from './events/events_comment_create.js';
+import type {CommentMove} from './events/events_comment_move.js';
+import type {ViewportChange} from './events/events_viewport.js';
+import * as eventUtils from './events/utils.js';
+import type {IBoundedElement} from './interfaces/i_bounded_element.js';
+import type {ContainerRegion, MetricsManager} from './metrics_manager.js';
+import * as mathUtils from './utils/math.js';
+import type {WorkspaceCommentSvg} from './workspace_comment_svg.js';
+import type {WorkspaceSvg} from './workspace_svg.js';
 
 
 /**
  * Bumps the given object that has passed out of bounds.
- * @param {!WorkspaceSvg} workspace The workspace containing the object.
- * @param {!MetricsManager.ContainerRegion} scrollMetrics Scroll metrics
+ * @param workspace The workspace containing the object.
+ * @param scrollMetrics Scroll metrics
  *    in workspace coordinates.
- * @param {!IBoundedElement} object The object to bump.
- * @return {boolean} True if block was bumped.
+ * @param object The object to bump.
+ * @return True if block was bumped.
  * @alias Blockly.bumpObjects.bumpIntoBounds
  */
-const bumpObjectIntoBounds = function(workspace, scrollMetrics, object) {
+function bumpObjectIntoBounds(
+    workspace: WorkspaceSvg, scrollMetrics: ContainerRegion,
+    object: IBoundedElement): boolean {
   // Compute new top/left position for object.
   const objectMetrics = object.getBoundingRectangle();
   const height = objectMetrics.bottom - objectMetrics.top;
@@ -82,27 +81,29 @@ const bumpObjectIntoBounds = function(workspace, scrollMetrics, object) {
     return true;
   }
   return false;
-};
-exports.bumpIntoBounds = bumpObjectIntoBounds;
+}
+export const bumpIntoBounds = bumpObjectIntoBounds;
 
 /**
  * Creates a handler for bumping objects when they cross fixed bounds.
- * @param {!WorkspaceSvg} workspace The workspace to handle.
- * @return {function(Abstract)} The event handler.
+ * @param workspace The workspace to handle.
+ * @return The event handler.
  * @alias Blockly.bumpObjects.bumpIntoBoundsHandler
  */
-const bumpIntoBoundsHandler = function(workspace) {
-  return function(e) {
+export function bumpIntoBoundsHandler(workspace: WorkspaceSvg):
+    (p1: Abstract) => void {
+  return (e) => {
     const metricsManager = workspace.getMetricsManager();
     if (!metricsManager.hasFixedEdges() || workspace.isDragging()) {
       return;
     }
 
-    if (eventUtils.BUMP_EVENTS.indexOf(e.type) !== -1) {
+    if (eventUtils.BUMP_EVENTS.indexOf(e.type ?? '') !== -1) {
       const scrollMetricsInWsCoords = metricsManager.getScrollMetrics(true);
 
       // Triggered by move/create event
-      const object = extractObjectFromEvent(workspace, e);
+      const object =
+          extractObjectFromEvent(workspace, e as eventUtils.BumpEvent);
       if (!object) {
         return;
       }
@@ -111,8 +112,7 @@ const bumpIntoBoundsHandler = function(workspace) {
       eventUtils.setGroup(e.group);
 
       const wasBumped = bumpObjectIntoBounds(
-          workspace, scrollMetricsInWsCoords,
-          /** @type {!IBoundedElement} */ (object));
+          workspace, scrollMetricsInWsCoords, (object as IBoundedElement));
 
       if (wasBumped && !e.group) {
         console.warn(
@@ -123,49 +123,52 @@ const bumpIntoBoundsHandler = function(workspace) {
         eventUtils.setGroup(oldGroup);
       }
     } else if (e.type === eventUtils.VIEWPORT_CHANGE) {
-      const viewportEvent = /** @type {!ViewportChange} */ (e);
-      if (viewportEvent.scale > viewportEvent.oldScale) {
+      const viewportEvent = (e as ViewportChange);
+      if (viewportEvent.scale && viewportEvent.oldScale &&
+          viewportEvent.scale > viewportEvent.oldScale) {
         bumpTopObjectsIntoBounds(workspace);
       }
     }
   };
-};
-exports.bumpIntoBoundsHandler = bumpIntoBoundsHandler;
+}
 
 /**
  * Extracts the object from the given event.
- * @param {!WorkspaceSvg} workspace The workspace the event originated
+ * @param workspace The workspace the event originated
  *    from.
- * @param {!eventUtils.BumpEvent} e An event containing an object.
- * @return {?BlockSvg|?WorkspaceCommentSvg} The extracted
+ * @param e An event containing an object.
+ * @return The extracted
  *    object.
  */
-const extractObjectFromEvent = function(workspace, e) {
+function extractObjectFromEvent(
+    workspace: WorkspaceSvg, e: eventUtils.BumpEvent): BlockSvg|null|
+    WorkspaceCommentSvg {
   let object = null;
   switch (e.type) {
     case eventUtils.BLOCK_CREATE:
     case eventUtils.BLOCK_MOVE:
-      object = workspace.getBlockById(e.blockId);
+      object = workspace.getBlockById((e as BlockCreate | BlockMove).blockId);
       if (object) {
         object = object.getRootBlock();
       }
       break;
     case eventUtils.COMMENT_CREATE:
     case eventUtils.COMMENT_MOVE:
-      object = (
-          /** @type {?WorkspaceCommentSvg} */
-          (workspace.getCommentById(e.commentId)));
+      object = workspace.getCommentById(
+                   (e as CommentCreate | CommentMove).commentId) as
+              WorkspaceCommentSvg |
+          null;
       break;
   }
   return object;
-};
+}
 
 /**
  * Bumps the top objects in the given workspace into bounds.
- * @param {!WorkspaceSvg} workspace The workspace.
+ * @param workspace The workspace.
  * @alias Blockly.bumpObjects.bumpTopObjectsIntoBounds
  */
-const bumpTopObjectsIntoBounds = function(workspace) {
+export function bumpTopObjectsIntoBounds(workspace: WorkspaceSvg) {
   const metricsManager = workspace.getMetricsManager();
   if (!metricsManager.hasFixedEdges() || workspace.isDragging()) {
     return;
@@ -173,8 +176,7 @@ const bumpTopObjectsIntoBounds = function(workspace) {
 
   const scrollMetricsInWsCoords = metricsManager.getScrollMetrics(true);
   const topBlocks = workspace.getTopBoundedElements();
-  for (let i = 0, block; (block = topBlocks[i]); i++) {
+  for (let i = 0, block; block = topBlocks[i]; i++) {
     bumpObjectIntoBounds(workspace, scrollMetricsInWsCoords, block);
   }
-};
-exports.bumpTopObjectsIntoBounds = bumpTopObjectsIntoBounds;
+}

package/core/clipboard.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ICopyable } from './interfaces/i_copyable.js';
+/**
+ * Copy a block or workspace comment onto the local clipboard.
+ * @param toCopy Block or Workspace Comment to be copied.
+ * @alias Blockly.clipboard.copy
+ * @internal
+ */
+export declare function copy(toCopy: ICopyable): void;
+/**
+ * Private version of copy for stubbing in tests.
+ */
+declare function copyInternal(toCopy: ICopyable): void;
+/**
+ * Paste a block or workspace comment on to the main workspace.
+ * @return The pasted thing if the paste was successful, null otherwise.
+ * @alias Blockly.clipboard.paste
+ * @internal
+ */
+export declare function paste(): ICopyable | null;
+/**
+ * Duplicate this block and its children, or a workspace comment.
+ * @param toDuplicate Block or Workspace Comment to be duplicated.
+ * @return The block or workspace comment that was duplicated, or null if the
+ *     duplication failed.
+ * @alias Blockly.clipboard.duplicate
+ * @internal
+ */
+export declare function duplicate(toDuplicate: ICopyable): ICopyable | null;
+/**
+ * Private version of duplicate for stubbing in tests.
+ */
+declare function duplicateInternal(toDuplicate: ICopyable): ICopyable | null;
+export declare const TEST_ONLY: {
+    duplicateInternal: typeof duplicateInternal;
+    copyInternal: typeof copyInternal;
+};
+export {};

package/core/clipboard.ts

@@ -0,0 +1,91 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Blockly's internal clipboard for managing copy-paste.
+ */
+
+/**
+ * Blockly's internal clipboard for managing copy-paste.
+ * @namespace Blockly.clipboard
+ */
+import * as goog from '../closure/goog/goog.js';
+goog.declareModuleId('Blockly.clipboard');
+
+import type {CopyData, ICopyable} from './interfaces/i_copyable.js';
+
+
+/** Metadata about the object that is currently on the clipboard. */
+let copyData: CopyData|null = null;
+
+/**
+ * Copy a block or workspace comment onto the local clipboard.
+ * @param toCopy Block or Workspace Comment to be copied.
+ * @alias Blockly.clipboard.copy
+ * @internal
+ */
+export function copy(toCopy: ICopyable) {
+  TEST_ONLY.copyInternal(toCopy);
+}
+
+/**
+ * Private version of copy for stubbing in tests.
+ */
+function copyInternal(toCopy: ICopyable) {
+  copyData = toCopy.toCopyData();
+}
+
+/**
+ * Paste a block or workspace comment on to the main workspace.
+ * @return The pasted thing if the paste was successful, null otherwise.
+ * @alias Blockly.clipboard.paste
+ * @internal
+ */
+export function paste(): ICopyable|null {
+  if (!copyData) {
+    return null;
+  }
+  // Pasting always pastes to the main workspace, even if the copy
+  // started in a flyout workspace.
+  let workspace = copyData.source;
+  if (workspace.isFlyout) {
+    workspace = workspace.targetWorkspace;
+  }
+  if (copyData.typeCounts &&
+      workspace.isCapacityAvailable(copyData.typeCounts)) {
+    return workspace.paste(copyData.saveInfo);
+  }
+  return null;
+}
+
+/**
+ * Duplicate this block and its children, or a workspace comment.
+ * @param toDuplicate Block or Workspace Comment to be duplicated.
+ * @return The block or workspace comment that was duplicated, or null if the
+ *     duplication failed.
+ * @alias Blockly.clipboard.duplicate
+ * @internal
+ */
+export function duplicate(toDuplicate: ICopyable): ICopyable|null {
+  return TEST_ONLY.duplicateInternal(toDuplicate);
+}
+
+/**
+ * Private version of duplicate for stubbing in tests.
+ */
+function duplicateInternal(toDuplicate: ICopyable): ICopyable|null {
+  const oldCopyData = copyData;
+  copy(toDuplicate);
+  const pastedThing =
+      toDuplicate.toCopyData()?.source?.paste(copyData!.saveInfo) ?? null;
+  copyData = oldCopyData;
+  return pastedThing;
+}
+
+export const TEST_ONLY = {
+  duplicateInternal,
+  copyInternal,
+}