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

package/core/block_animations.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { BlockSvg } from './block_svg.js';
+/**
+ * Play some UI effects (sound, animation) when disposing of a block.
+ *
+ * @param block The block being disposed of.
+ * @alias Blockly.blockAnimations.disposeUiEffect
+ * @internal
+ */
+export declare function disposeUiEffect(block: BlockSvg): void;
+/**
+ * Play some UI effects (sound, ripple) after a connection has been established.
+ *
+ * @param block The block being connected.
+ * @alias Blockly.blockAnimations.connectionUiEffect
+ * @internal
+ */
+export declare function connectionUiEffect(block: BlockSvg): void;
+/**
+ * Play some UI effects (sound, animation) when disconnecting a block.
+ *
+ * @param block The block being disconnected.
+ * @alias Blockly.blockAnimations.disconnectUiEffect
+ * @internal
+ */
+export declare function disconnectUiEffect(block: BlockSvg): void;
+/**
+ * Stop the disconnect UI animation immediately.
+ *
+ * @alias Blockly.blockAnimations.disconnectUiStop
+ * @internal
+ */
+export declare function disconnectUiStop(): void;
+//# sourceMappingURL=block_animations.d.ts.map

package/core/block_drag_surface.d.ts

@@ -0,0 +1,124 @@
+/**
+ * @license
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Coordinate } from './utils/coordinate.js';
+/**
+ * Class for a drag surface for the currently dragged block. This is a separate
+ * SVG that contains only the currently moving block, or nothing.
+ *
+ * @alias Blockly.BlockDragSurfaceSvg
+ */
+export declare class BlockDragSurfaceSvg {
+    private readonly container;
+    /** The SVG drag surface. Set once by BlockDragSurfaceSvg.createDom. */
+    private svg_;
+    /**
+     * This is where blocks live while they are being dragged if the drag
+     * surface is enabled.
+     */
+    private dragGroup_;
+    /**
+     * Cached value for the scale of the drag surface.
+     * Used to set/get the correct translation during and after a drag.
+     */
+    private scale_;
+    /**
+     * Cached value for the translation of the drag surface.
+     * This translation is in pixel units, because the scale is applied to the
+     * drag group rather than the top-level SVG.
+     */
+    private surfaceXY_;
+    private readonly childSurfaceXY_;
+    /** @param container Containing element. */
+    constructor(container: Element);
+    /** Create the drag surface and inject it into the container. */
+    createDom(): void;
+    /**
+     * Set the SVG blocks on the drag surface's group and show the surface.
+     * Only one block group should be on the drag surface at a time.
+     *
+     * @param blocks Block or group of blocks to place on the drag surface.
+     */
+    setBlocksAndShow(blocks: SVGElement): void;
+    /**
+     * Translate and scale the entire drag surface group to the given position, to
+     * keep in sync with the workspace.
+     *
+     * @param x X translation in pixel coordinates.
+     * @param y Y translation in pixel coordinates.
+     * @param scale Scale of the group.
+     */
+    translateAndScaleGroup(x: number, y: number, scale: number): void;
+    /**
+     * Translate the drag surface's SVG based on its internal state.
+     *
+     * @internal
+     */
+    translateSurfaceInternal_(): void;
+    /**
+     * Translates the entire surface by a relative offset.
+     *
+     * @param deltaX Horizontal offset in pixel units.
+     * @param deltaY Vertical offset in pixel units.
+     */
+    translateBy(deltaX: number, deltaY: number): void;
+    /**
+     * Translate the entire drag surface during a drag.
+     * We translate the drag surface instead of the blocks inside the surface
+     * so that the browser avoids repainting the SVG.
+     * Because of this, the drag coordinates must be adjusted by scale.
+     *
+     * @param x X translation for the entire surface.
+     * @param y Y translation for the entire surface.
+     */
+    translateSurface(x: number, y: number): void;
+    /**
+     * Reports the surface translation in scaled workspace coordinates.
+     * Use this when finishing a drag to return blocks to the correct position.
+     *
+     * @returns Current translation of the surface.
+     */
+    getSurfaceTranslation(): Coordinate;
+    /**
+     * Provide a reference to the drag group (primarily for
+     * BlockSvg.getRelativeToSurfaceXY).
+     *
+     * @returns Drag surface group element.
+     */
+    getGroup(): SVGElement | null;
+    /**
+     * Returns the SVG drag surface.
+     *
+     * @returns The SVG drag surface.
+     */
+    getSvgRoot(): SVGElement | null;
+    /**
+     * Get the current blocks on the drag surface, if any (primarily
+     * for BlockSvg.getRelativeToSurfaceXY).
+     *
+     * @returns Drag surface block DOM element, or null if no blocks exist.
+     */
+    getCurrentBlock(): Element | null;
+    /**
+     * Gets the translation of the child block surface
+     * This surface is in charge of keeping track of how much the workspace has
+     * moved.
+     *
+     * @returns The amount the workspace has been moved.
+     */
+    getWsTranslation(): Coordinate;
+    /**
+     * Clear the group and hide the surface; move the blocks off onto the provided
+     * element.
+     * If the block is being deleted it doesn't need to go back to the original
+     * surface, since it would be removed immediately during dispose.
+     *
+     * @param opt_newSurface Surface the dragging blocks should be moved to, or
+     *     null if the blocks should be removed from this surface without being
+     *     moved to a different surface.
+     */
+    clearAndHide(opt_newSurface?: Element): void;
+}
+//# sourceMappingURL=block_drag_surface.d.ts.map

package/core/block_dragger.d.ts

@@ -0,0 +1,158 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import './events/events_block_drag.js';
+import type { BlockSvg } from './block_svg.js';
+import type { Icon } from './icon.js';
+import { InsertionMarkerManager } from './insertion_marker_manager.js';
+import type { IBlockDragger } from './interfaces/i_block_dragger.js';
+import { Coordinate } from './utils/coordinate.js';
+import type { WorkspaceSvg } from './workspace_svg.js';
+/**
+ * Class for a block dragger.  It moves blocks around the workspace when they
+ * are being dragged by a mouse or touch.
+ *
+ * @alias Blockly.BlockDragger
+ */
+export declare class BlockDragger implements IBlockDragger {
+    /** The top block in the stack that is being dragged. */
+    protected draggingBlock_: BlockSvg;
+    protected draggedConnectionManager_: InsertionMarkerManager;
+    /** The workspace on which the block is being dragged. */
+    protected workspace_: WorkspaceSvg;
+    /** Which drag area the mouse pointer is over, if any. */
+    private dragTarget_;
+    /** Whether the block would be deleted if dropped immediately. */
+    protected wouldDeleteBlock_: boolean;
+    protected startXY_: Coordinate;
+    protected dragIconData_: IconPositionData[];
+    /**
+     * @param block The block to drag.
+     * @param workspace The workspace to drag on.
+     */
+    constructor(block: BlockSvg, workspace: WorkspaceSvg);
+    /**
+     * Sever all links from this object.
+     *
+     * @internal
+     */
+    dispose(): void;
+    /**
+     * Start dragging a block.  This includes moving it to the drag surface.
+     *
+     * @param currentDragDeltaXY How far the pointer has moved from the position
+     *     at mouse down, in pixel units.
+     * @param healStack Whether or not to heal the stack after disconnecting.
+     */
+    startDrag(currentDragDeltaXY: Coordinate, healStack: boolean): void;
+    /**
+     * Whether or not we should disconnect the block when a drag is started.
+     *
+     * @param healStack Whether or not to heal the stack after disconnecting.
+     * @returns True to disconnect the block, false otherwise.
+     */
+    protected shouldDisconnect_(healStack: boolean): boolean;
+    /**
+     * Disconnects the block and moves it to a new location.
+     *
+     * @param healStack Whether or not to heal the stack after disconnecting.
+     * @param currentDragDeltaXY How far the pointer has moved from the position
+     *     at mouse down, in pixel units.
+     */
+    protected disconnectBlock_(healStack: boolean, currentDragDeltaXY: Coordinate): void;
+    /** Fire a UI event at the start of a block drag. */
+    protected fireDragStartEvent_(): void;
+    /**
+     * Execute a step of block 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.
+     */
+    drag(e: Event, currentDragDeltaXY: Coordinate): void;
+    /**
+     * Finish a block drag and put the block 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.
+     */
+    endDrag(e: Event, currentDragDeltaXY: Coordinate): void;
+    /**
+     * Calculates the drag delta and new location values after a block is dragged.
+     *
+     * @param currentDragDeltaXY How far the pointer has moved from the start of
+     *     the drag, in pixel units.
+     * @returns New location after drag. delta is in workspace units. newLocation
+     *     is the new coordinate where the block should end up.
+     */
+    protected getNewLocationAfterDrag_(currentDragDeltaXY: Coordinate): {
+        delta: Coordinate;
+        newLocation: Coordinate;
+    };
+    /**
+     * May delete the dragging block, if allowed. If `this.wouldDeleteBlock_` is
+     * not true, the block will not be deleted. This should be called at the end
+     * of a block drag.
+     *
+     * @returns True if the block was deleted.
+     */
+    protected maybeDeleteBlock_(): boolean;
+    /**
+     * Updates the necessary information to place a block at a certain location.
+     *
+     * @param delta The change in location from where the block started the drag
+     *     to where it ended the drag.
+     */
+    protected updateBlockAfterMove_(delta: Coordinate): void;
+    /** Fire a UI event at the end of a block drag. */
+    protected fireDragEndEvent_(): void;
+    /**
+     * Adds or removes the style of the cursor for the toolbox.
+     * This is what changes the cursor to display an x when a deletable block is
+     * held over the toolbox.
+     *
+     * @param isEnd True if we are at the end of a drag, false otherwise.
+     */
+    protected updateToolboxStyle_(isEnd: boolean): void;
+    /** Fire a move event at the end of a block drag. */
+    protected fireMoveEvent_(): void;
+    /**
+     * Update the cursor (and possibly the trash can lid) to reflect whether the
+     * dragging block would be deleted if released immediately.
+     */
+    protected updateCursorDuringBlockDrag_(): void;
+    /**
+     * 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.
+     * @returns The input coordinate divided by the workspace scale.
+     */
+    protected pixelsToWorkspaceUnits_(pixelCoord: Coordinate): Coordinate;
+    /**
+     * Move all of the icons connected to this drag.
+     *
+     * @param dxy How far to move the icons from their original positions, in
+     *     workspace units.
+     */
+    protected dragIcons_(dxy: Coordinate): void;
+    /**
+     * Get a list of the insertion markers that currently exist.  Drags have 0, 1,
+     * or 2 insertion markers.
+     *
+     * @returns A possibly empty list of insertion marker blocks.
+     */
+    getInsertionMarkers(): BlockSvg[];
+}
+/** Data about the position of a given icon. */
+export interface IconPositionData {
+    location: Coordinate;
+    icon: Icon;
+}
+//# sourceMappingURL=block_dragger.d.ts.map