CodingPirates/blockly
1
0
Fork 0
mirror of https://github.com/google/blockly.git synced 2026-01-26 18:20:10 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
de330c887498aab09ad71b4bb40cc50fe77f3bf8
blockly/typings/blockly.d.ts
Beka Westberg 30d7f0914e Rebuild (#4975)
2021-07-01 08:17:08 -07:00

23282 lines
832 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/**
* @license
* Copyright 2019 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @fileoverview Type definitions for Blockly.
* @author samelh@google.com (Sam El-Husseini)
*/
export = Blockly;
declare module Blockly {
interface BlocklyOptions {
toolbox?: Blockly.utils.toolbox.ToolboxDefinition;
readOnly?: boolean;
trashcan?: boolean;
maxInstances?: {[type: string]: number;};
maxTrashcanContents?: number;
collapse?: boolean;
comments?: boolean;
disable?: boolean;
sounds?: boolean;
rtl?: boolean;
horizontalLayout?: boolean;
toolboxPosition?: string;
css?: boolean;
oneBasedIndex?: boolean;
media?: string;
theme?: Blockly.Theme | BlocklyThemeOptions;
move?: {
scrollbars?: boolean;
drag?: boolean;
wheel?: boolean;
};
grid?: {
spacing?: number;
colour?: string;
length?: number;
snap?: boolean;
};
zoom?: {
controls?: boolean;
wheel?: boolean;
startScale?: number;
maxScale?: number;
minScale?: number;
scaleSpeed?: number;
pinch?: boolean;
};
renderer?: string;
parentWorkspace?: Blockly.WorkspaceSvg;
}
interface BlocklyThemeOptions {
base?: string;
blockStyles?: {[blocks: string]: Blockly.Theme.BlockStyle;};
categoryStyles?: {[category: string]: Blockly.Theme.CategoryStyle;};
componentStyles?: {[component: string]: any;};
fontStyle?: Blockly.Theme.FontStyle;
startHats?: boolean;
}
/**
* Set the Blockly locale.
* Note: this method is only available in the npm release of Blockly.
* @param {!Object} msg An object of Blockly message strings in the desired
* language.
*/
function setLocale(msg: {[key: string]: string;}): void;
}
declare module Blockly.utils {
interface Metrics {
viewHeight: number;
viewWidth: number;
contentHeight: number;
contentWidth: number;
viewTop: number;
viewLeft: number;
contentTop: number;
contentLeft: number;
absoluteTop: number;
absoluteLeft: number;
svgHeight?: number;
svgWidth?: number;
toolboxWidth?: number;
toolboxHeight?: number;
flyoutWidth?: number;
flyoutHeight?: number;
toolboxPosition?: number;
}
}
declare module Blockly {
class Block extends Block__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Block__Class implements Blockly.IASTNodeLocation, Blockly.IDeletable {
/**
* Class for one block.
* Not normally called directly, workspace.newBlock() is preferred.
* @param {!Blockly.Workspace} workspace The block's workspace.
* @param {!string} prototypeName Name of the language object containing
* type-specific functions for this block.
* @param {string=} opt_id Optional ID. Use this ID if provided, otherwise
* create a new ID.
* @constructor
* @implements {Blockly.IASTNodeLocation}
* @implements {Blockly.IDeletable}
* @throws When the prototypeName is not valid or not allowed.
*/
constructor(workspace: Blockly.Workspace, prototypeName: string, opt_id?: string);
/** @type {string} */
id: string;
/** @type {Blockly.Connection} */
outputConnection: Blockly.Connection;
/** @type {Blockly.Connection} */
nextConnection: Blockly.Connection;
/** @type {Blockly.Connection} */
previousConnection: Blockly.Connection;
/** @type {!Array<!Blockly.Input>} */
inputList: Blockly.Input[];
/** @type {boolean|undefined} */
inputsInline: boolean|any /*undefined*/;
/** @type {!Blockly.Tooltip.TipInfo} */
tooltip: Blockly.Tooltip.TipInfo;
/** @type {boolean} */
contextMenu: boolean;
/**
* @type {Blockly.Block}
* @protected
*/
parentBlock_: Blockly.Block;
/**
* @type {!Array<!Blockly.Block>}
* @protected
*/
childBlocks_: Blockly.Block[];
/**
* @type {boolean}
* @protected
*/
collapsed_: boolean;
/**
* @type {?number}
* @protected
*/
outputShape_: number;
/**
* A string representing the comment attached to this block.
* @type {string|Blockly.Comment}
* @deprecated August 2019. Use getCommentText instead.
*/
comment: string|Blockly.Comment;
/**
* A model of the comment attached to this block.
* @type {!Blockly.Block.CommentModel}
* @package
*/
commentModel: Blockly.Block.CommentModel;
/** @type {!Blockly.Workspace} */
workspace: Blockly.Workspace;
/** @type {boolean} */
isInFlyout: boolean;
/** @type {boolean} */
isInMutator: boolean;
/** @type {boolean} */
RTL: boolean;
/**
* True if this block is an insertion marker.
* @type {boolean}
* @protected
*/
isInsertionMarker_: boolean;
/**
* Name of the type of hat.
* @type {string|undefined}
*/
hat: string|any /*undefined*/;
/** @type {?boolean} */
rendered: boolean;
/**
* A count of statement inputs on the block.
* @type {number}
* @package
*/
statementInputCount: number;
/** @type {string} */
type: string;
/** @type {boolean|undefined} */
inputsInlineDefault: boolean|any /*undefined*/;
/**
* Optional text data that round-trips between blocks and XML.
* Has no effect. May be used by 3rd parties for meta information.
* @type {?string}
*/
data: string;
/**
* Has this block been disposed of?
* @type {boolean}
* @package
*/
disposed: boolean;
/**
* Colour of the block in '#RRGGBB' format.
* @type {string}
* @protected
*/
colour_: string;
/**
* Name of the block style.
* @type {string}
* @protected
*/
styleName_: string;
/**
* An optional method called during initialization.
* @type {?function()}
*/
init: { (): any /*missing*/ };
/**
* An optional callback method to use whenever the block's parent workspace
* changes. This is usually only called from the constructor, the block type
* initializer function, or an extension initializer function.
* @type {?function(Blockly.Events.Abstract)}
*/
onchange: { (_0: Blockly.Events.Abstract): any /*missing*/ };
/**
* An optional serialization method for defining how to serialize the
* mutation state. This must be coupled with defining `domToMutation`.
* @type {?function(...):!Element}
*/
mutationToDom: any /*missing*/;
/**
* An optional deserialization method for defining how to deserialize the
* mutation state. This must be coupled with defining `mutationToDom`.
* @type {?function(!Element)}
*/
domToMutation: { (_0: Element): any /*missing*/ };
/**
* An optional property for suppressing adding STATEMENT_PREFIX and
* STATEMENT_SUFFIX to generated code.
* @type {?boolean}
*/
suppressPrefixSuffix: boolean;
/**
* An optional property for declaring developer variables. Return a list of
* variable names for use by generators. Developer variables are never shown to
* the user, but are declared as global variables in the generated code.
* @type {?function():!Array<string>}
*/
getDeveloperVariables: { (): string[] };
/**
* Dispose of this block.
* @param {boolean} healStack If true, then try to heal any gap by connecting
* the next statement with the previous statement. Otherwise, dispose of
* all children of this block.
* @suppress {checkTypes}
*/
dispose(healStack: boolean): void;
/**
* Call initModel on all fields on the block.
* May be called more than once.
* Either initModel or initSvg must be called after creating a block and before
* the first interaction with it. Interactions include UI actions
* (e.g. clicking and dragging) and firing events (e.g. create, delete, and
* change).
* @public
*/
initModel(): void;
/**
* Unplug this block from its superior block. If this block is a statement,
* optionally reconnect the block underneath with the block on top.
* @param {boolean=} opt_healStack Disconnect child statement and reconnect
* stack. Defaults to false.
*/
unplug(opt_healStack?: boolean): void;
/**
* Returns all connections originating from this block.
* @param {boolean} _all If true, return all connections even hidden ones.
* @return {!Array<!Blockly.Connection>} Array of connections.
* @package
*/
getConnections_(_all: boolean): Blockly.Connection[];
/**
* Walks down a stack of blocks and finds the last next connection on the stack.
* @param {boolean} ignoreShadows If true,the last connection on a non-shadow
* block will be returned. If false, this will follow shadows to find the
* last connection.
* @return {?Blockly.Connection} The last next connection on the stack, or null.
* @package
*/
lastConnectionInStack(ignoreShadows: boolean): Blockly.Connection;
/**
* Bump unconnected blocks out of alignment. Two blocks which aren't actually
* connected should not coincidentally line up on screen.
*/
bumpNeighbours(): void;
/**
* Return the parent block or null if this block is at the top level. The parent
* block is either the block connected to the previous connection (for a statement
* block) or the block connected to the output connection (for a value block).
* @return {?Blockly.Block} The block (if any) that holds the current block.
*/
getParent(): Blockly.Block;
/**
* Return the input that connects to the specified block.
* @param {!Blockly.Block} block A block connected to an input on this block.
* @return {?Blockly.Input} The input (if any) that connects to the specified
* block.
*/
getInputWithBlock(block: Blockly.Block): Blockly.Input;
/**
* Return the parent block that surrounds the current block, or null if this
* block has no surrounding block. A parent block might just be the previous
* statement, whereas the surrounding block is an if statement, while loop, etc.
* @return {?Blockly.Block} The block (if any) that surrounds the current block.
*/
getSurroundParent(): Blockly.Block;
/**
* Return the next statement block directly connected to this block.
* @return {?Blockly.Block} The next statement block or null.
*/
getNextBlock(): Blockly.Block;
/**
* Returns the block connected to the previous connection.
* @return {?Blockly.Block} The previous statement block or null.
*/
getPreviousBlock(): Blockly.Block;
/**
* Return the connection on the first statement input on this block, or null if
* there are none.
* @return {?Blockly.Connection} The first statement connection or null.
* @package
*/
getFirstStatementConnection(): Blockly.Connection;
/**
* Return the top-most block in this block's tree.
* This will return itself if this block is at the top level.
* @return {!Blockly.Block} The root block.
*/
getRootBlock(): Blockly.Block;
/**
* Walk up from the given block up through the stack of blocks to find
* the top block of the sub stack. If we are nested in a statement input only
* find the top-most nested block. Do not go all the way to the root block.
* @return {!Blockly.Block} The top block in a stack.
* @package
*/
getTopStackBlock(): Blockly.Block;
/**
* Find all the blocks that are directly nested inside this one.
* Includes value and statement inputs, as well as any following statement.
* Excludes any connection on an output tab or any preceding statement.
* Blocks are optionally sorted by position; top to bottom.
* @param {boolean} ordered Sort the list if true.
* @return {!Array<!Blockly.Block>} Array of blocks.
*/
getChildren(ordered: boolean): Blockly.Block[];
/**
* Set parent of this block to be a new block or null.
* @param {Blockly.Block} newParent New parent block.
*/
setParent(newParent: Blockly.Block): void;
/**
* Find all the blocks that are directly or indirectly nested inside this one.
* Includes this block in the list.
* Includes value and statement inputs, as well as any following statements.
* Excludes any connection on an output tab or any preceding statements.
* Blocks are optionally sorted by position; top to bottom.
* @param {boolean} ordered Sort the list if true.
* @return {!Array<!Blockly.Block>} Flattened array of blocks.
*/
getDescendants(ordered: boolean): Blockly.Block[];
/**
* Get whether this block is deletable or not.
* @return {boolean} True if deletable.
*/
isDeletable(): boolean;
/**
* Set whether this block is deletable or not.
* @param {boolean} deletable True if deletable.
*/
setDeletable(deletable: boolean): void;
/**
* Get whether this block is movable or not.
* @return {boolean} True if movable.
*/
isMovable(): boolean;
/**
* Set whether this block is movable or not.
* @param {boolean} movable True if movable.
*/
setMovable(movable: boolean): void;
/**
* Get whether is block is duplicatable or not. If duplicating this block and
* descendants will put this block over the workspace's capacity this block is
* not duplicatable. If duplicating this block and descendants will put any
* type over their maxInstances this block is not duplicatable.
* @return {boolean} True if duplicatable.
*/
isDuplicatable(): boolean;
/**
* Get whether this block is a shadow block or not.
* @return {boolean} True if a shadow.
*/
isShadow(): boolean;
/**
* Set whether this block is a shadow block or not.
* @param {boolean} shadow True if a shadow.
*/
setShadow(shadow: boolean): void;
/**
* Get whether this block is an insertion marker block or not.
* @return {boolean} True if an insertion marker.
*/
isInsertionMarker(): boolean;
/**
* Set whether this block is an insertion marker block or not.
* Once set this cannot be unset.
* @param {boolean} insertionMarker True if an insertion marker.
* @package
*/
setInsertionMarker(insertionMarker: boolean): void;
/**
* Get whether this block is editable or not.
* @return {boolean} True if editable.
*/
isEditable(): boolean;
/**
* Set whether this block is editable or not.
* @param {boolean} editable True if editable.
*/
setEditable(editable: boolean): void;
/**
* Returns if this block has been disposed of / deleted.
* @return {boolean} True if this block has been disposed of / deleted.
*/
isDisposed(): boolean;
/**
* Find the connection on this block that corresponds to the given connection
* on the other block.
* Used to match connections between a block and its insertion marker.
* @param {!Blockly.Block} otherBlock The other block to match against.
* @param {!Blockly.Connection} conn The other connection to match.
* @return {?Blockly.Connection} The matching connection on this block, or null.
* @package
*/
getMatchingConnection(otherBlock: Blockly.Block, conn: Blockly.Connection): Blockly.Connection;
/**
* Set the URL of this block's help page.
* @param {string|Function} url URL string for block help, or function that
* returns a URL. Null for no help.
*/
setHelpUrl(url: string|Function): void;
/**
* Sets the tooltip for this block.
* @param {!Blockly.Tooltip.TipInfo} newTip The text for the tooltip, a function
* that returns the text for the tooltip, or a parent object whose tooltip
* will be used. To not display a tooltip pass the empty string.
*/
setTooltip(newTip: Blockly.Tooltip.TipInfo): void;
/**
* Returns the tooltip text for this block.
* @return {!string} The tooltip text for this block.
*/
getTooltip(): string;
/**
* Get the colour of a block.
* @return {string} #RRGGBB string.
*/
getColour(): string;
/**
* Get the name of the block style.
* @return {string} Name of the block style.
*/
getStyleName(): string;
/**
* Get the HSV hue value of a block. Null if hue not set.
* @return {?number} Hue value (0-360).
*/
getHue(): number;
/**
* Change the colour of a block.
* @param {number|string} colour HSV hue value (0 to 360), #RRGGBB string,
* or a message reference string pointing to one of those two values.
*/
setColour(colour: number|string): void;
/**
* Set the style and colour values of a block.
* @param {string} blockStyleName Name of the block style.
*/
setStyle(blockStyleName: string): void;
/**
* Sets a callback function to use whenever the block's parent workspace
* changes, replacing any prior onchange handler. This is usually only called
* from the constructor, the block type initializer function, or an extension
* initializer function.
* @param {function(Blockly.Events.Abstract)} onchangeFn The callback to call
* when the block's workspace changes.
* @throws {Error} if onchangeFn is not falsey and not a function.
*/
setOnChange(onchangeFn: { (_0: Blockly.Events.Abstract): any /*missing*/ }): void;
/**
* Returns the named field from a block.
* @param {string} name The name of the field.
* @return {?Blockly.Field} Named field, or null if field does not exist.
*/
getField(name: string): Blockly.Field;
/**
* Return all variables referenced by this block.
* @return {!Array<string>} List of variable names.
*/
getVars(): string[];
/**
* Return all variables referenced by this block.
* @return {!Array<!Blockly.VariableModel>} List of variable models.
* @package
*/
getVarModels(): Blockly.VariableModel[];
/**
* Notification that a variable is renaming but keeping the same ID. If the
* variable is in use on this block, rerender to show the new name.
* @param {!Blockly.VariableModel} variable The variable being renamed.
* @package
*/
updateVarName(variable: Blockly.VariableModel): void;
/**
* Notification that a variable is renaming.
* If the ID matches one of this block's variables, rename it.
* @param {string} oldId ID of variable to rename.
* @param {string} newId ID of new variable. May be the same as oldId, but with
* an updated name.
*/
renameVarById(oldId: string, newId: string): void;
/**
* Returns the language-neutral value of the given field.
* @param {string} name The name of the field.
* @return {*} Value of the field or null if field does not exist.
*/
getFieldValue(name: string): any;
/**
* Sets the value of the given field for this block.
* @param {*} newValue The value to set.
* @param {string} name The name of the field to set the value of.
*/
setFieldValue(newValue: any, name: string): void;
/**
* Set whether this block can chain onto the bottom of another block.
* @param {boolean} newBoolean True if there can be a previous statement.
* @param {(string|Array<string>|null)=} opt_check Statement type or
* list of statement types. Null/undefined if any type could be connected.
*/
setPreviousStatement(newBoolean: boolean, opt_check?: string|string[]|any /*null*/): void;
/**
* Set whether another block can chain onto the bottom of this block.
* @param {boolean} newBoolean True if there can be a next statement.
* @param {(string|Array<string>|null)=} opt_check Statement type or
* list of statement types. Null/undefined if any type could be connected.
*/
setNextStatement(newBoolean: boolean, opt_check?: string|string[]|any /*null*/): void;
/**
* Set whether this block returns a value.
* @param {boolean} newBoolean True if there is an output.
* @param {(string|Array<string>|null)=} opt_check Returned type or list
* of returned types. Null or undefined if any type could be returned
* (e.g. variable get).
*/
setOutput(newBoolean: boolean, opt_check?: string|string[]|any /*null*/): void;
/**
* Set whether value inputs are arranged horizontally or vertically.
* @param {boolean} newBoolean True if inputs are horizontal.
*/
setInputsInline(newBoolean: boolean): void;
/**
* Get whether value inputs are arranged horizontally or vertically.
* @return {boolean} True if inputs are horizontal.
*/
getInputsInline(): boolean;
/**
* Set the block's output shape.
* @param {?number} outputShape Value representing an output shape.
*/
setOutputShape(outputShape: number): void;
/**
* Get the block's output shape.
* @return {?number} Value representing output shape if one exists.
*/
getOutputShape(): number;
/**
* Get whether this block is enabled or not.
* @return {boolean} True if enabled.
*/
isEnabled(): boolean;
/**
* Set whether the block is enabled or not.
* @param {boolean} enabled True if enabled.
*/
setEnabled(enabled: boolean): void;
/**
* Get whether the block is disabled or not due to parents.
* The block's own disabled property is not considered.
* @return {boolean} True if disabled.
*/
getInheritedDisabled(): boolean;
/**
* Get whether the block is collapsed or not.
* @return {boolean} True if collapsed.
*/
isCollapsed(): boolean;
/**
* Set whether the block is collapsed or not.
* @param {boolean} collapsed True if collapsed.
*/
setCollapsed(collapsed: boolean): void;
/**
* Create a human-readable text representation of this block and any children.
* @param {number=} opt_maxLength Truncate the string to this length.
* @param {string=} opt_emptyToken The placeholder string used to denote an
* empty field. If not specified, '?' is used.
* @return {string} Text of block.
*/
toString(opt_maxLength?: number, opt_emptyToken?: string): string;
/**
* Shortcut for appending a value input row.
* @param {string} name Language-neutral identifier which may used to find this
* input again. Should be unique to this block.
* @return {!Blockly.Input} The input object created.
*/
appendValueInput(name: string): Blockly.Input;
/**
* Shortcut for appending a statement input row.
* @param {string} name Language-neutral identifier which may used to find this
* input again. Should be unique to this block.
* @return {!Blockly.Input} The input object created.
*/
appendStatementInput(name: string): Blockly.Input;
/**
* Shortcut for appending a dummy input row.
* @param {string=} opt_name Language-neutral identifier which may used to find
* this input again. Should be unique to this block.
* @return {!Blockly.Input} The input object created.
*/
appendDummyInput(opt_name?: string): Blockly.Input;
/**
* Initialize this block using a cross-platform, internationalization-friendly
* JSON description.
* @param {!Object} json Structured data describing the block.
*/
jsonInit(json: Object): void;
/**
* Add key/values from mixinObj to this block object. By default, this method
* will check that the keys in mixinObj will not overwrite existing values in
* the block, including prototype values. This provides some insurance against
* mixin / extension incompatibilities with future block features. This check
* can be disabled by passing true as the second argument.
* @param {!Object} mixinObj The key/values pairs to add to this block object.
* @param {boolean=} opt_disableCheck Option flag to disable overwrite checks.
*/
mixin(mixinObj: Object, opt_disableCheck?: boolean): void;
/**
* Add a value input, statement input or local variable to this block.
* @param {number} type One of Blockly.inputTypes.
* @param {string} name Language-neutral identifier which may used to find this
* input again. Should be unique to this block.
* @return {!Blockly.Input} The input object created.
* @protected
*/
appendInput_(type: number, name: string): Blockly.Input;
/**
* Move a named input to a different location on this block.
* @param {string} name The name of the input to move.
* @param {?string} refName Name of input that should be after the moved input,
* or null to be the input at the end.
*/
moveInputBefore(name: string, refName: string): void;
/**
* Move a numbered input to a different location on this block.
* @param {number} inputIndex Index of the input to move.
* @param {number} refIndex Index of input that should be after the moved input.
*/
moveNumberedInputBefore(inputIndex: number, refIndex: number): void;
/**
* Remove an input from this block.
* @param {string} name The name of the input.
* @param {boolean=} opt_quiet True to prevent an error if input is not present.
* @return {boolean} True if operation succeeds, false if input is not present and opt_quiet is true
* @throws {Error} if the input is not present and opt_quiet is not true.
*/
removeInput(name: string, opt_quiet?: boolean): boolean;
/**
* Fetches the named input object.
* @param {string} name The name of the input.
* @return {?Blockly.Input} The input object, or null if input does not exist.
*/
getInput(name: string): Blockly.Input;
/**
* Fetches the block attached to the named input.
* @param {string} name The name of the input.
* @return {?Blockly.Block} The attached value block, or null if the input is
* either disconnected or if the input does not exist.
*/
getInputTargetBlock(name: string): Blockly.Block;
/**
* Returns the comment on this block (or null if there is no comment).
* @return {?string} Block's comment.
*/
getCommentText(): string;
/**
* Set this block's comment text.
* @param {?string} text The text, or null to delete.
*/
setCommentText(text: string): void;
/**
* Set this block's warning text.
* @param {?string} _text The text, or null to delete.
* @param {string=} _opt_id An optional ID for the warning text to be able to
* maintain multiple warnings.
*/
setWarningText(_text: string, _opt_id?: string): void;
/**
* Give this block a mutator dialog.
* @param {Blockly.Mutator} _mutator A mutator dialog instance or null to
* remove.
*/
setMutator(_mutator: Blockly.Mutator): void;
/**
* Return the coordinates of the top-left corner of this block relative to the
* drawing surface's origin (0,0), in workspace units.
* @return {!Blockly.utils.Coordinate} Object with .x and .y properties.
*/
getRelativeToSurfaceXY(): Blockly.utils.Coordinate;
/**
* Move a block by a relative offset.
* @param {number} dx Horizontal offset, in workspace units.
* @param {number} dy Vertical offset, in workspace units.
*/
moveBy(dx: number, dy: number): void;
/**
* Create a connection of the specified type.
* @param {number} type The type of the connection to create.
* @return {!Blockly.Connection} A new connection of the specified type.
* @protected
*/
makeConnection_(type: number): Blockly.Connection;
/**
* Recursively checks whether all statement and value inputs are filled with
* blocks. Also checks all following statement blocks in this stack.
* @param {boolean=} opt_shadowBlocksAreFilled An optional argument controlling
* whether shadow blocks are counted as filled. Defaults to true.
* @return {boolean} True if all inputs are filled, false otherwise.
*/
allInputsFilled(opt_shadowBlocksAreFilled?: boolean): boolean;
/**
* This method returns a string describing this Block in developer terms (type
* name and ID; English only).
*
* Intended to on be used in console logs and errors. If you need a string that
* uses the user's native language (including block text, field values, and
* child blocks), use [toString()]{@link Blockly.Block#toString}.
* @return {string} The description.
*/
toDevString(): string;
}
}
declare module Blockly.Block {
/**
* @typedef {{
* text:?string,
* pinned:boolean,
* size:Blockly.utils.Size
* }}
*/
interface CommentModel {
text: string;
pinned: boolean;
size: Blockly.utils.Size
}
/**
* The language-neutral ID given to the collapsed input.
* @const {string}
*/
var COLLAPSED_INPUT_NAME: any /*missing*/;
/**
* The language-neutral ID given to the collapsed field.
* @const {string}
*/
var COLLAPSED_FIELD_NAME: any /*missing*/;
}
declare module Blockly.blockAnimations {
/**
* Play some UI effects (sound, animation) when disposing of a block.
* @param {!Blockly.BlockSvg} block The block being disposed of.
* @package
*/
function disposeUiEffect(block: Blockly.BlockSvg): void;
/**
* Play some UI effects (sound, ripple) after a connection has been established.
* @param {!Blockly.BlockSvg} block The block being connected.
* @package
*/
function connectionUiEffect(block: Blockly.BlockSvg): void;
/**
* Play some UI effects (sound, animation) when disconnecting a block.
* @param {!Blockly.BlockSvg} block The block being disconnected.
* @package
*/
function disconnectUiEffect(block: Blockly.BlockSvg): void;
/**
* Stop the disconnect UI animation immediately.
* @package
*/
function disconnectUiStop(): void;
}
declare module Blockly {
class BlockDragSurfaceSvg extends BlockDragSurfaceSvg__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class BlockDragSurfaceSvg__Class {
/**
* Class for a drag surface for the currently dragged block. This is a separate
* SVG that contains only the currently moving block, or nothing.
* @param {!Element} container Containing element.
* @constructor
*/
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 {!SVGElement} 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 {number} x X translation in pixel coordinates.
* @param {number} y Y translation in pixel coordinates.
* @param {number} scale Scale of the group.
*/
translateAndScaleGroup(x: number, y: number, scale: number): void;
/**
* Translates the entire surface by a relative offset.
* @param {number} deltaX Horizontal offset in pixel units.
* @param {number} 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 {number} x X translation for the entire surface.
* @param {number} 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.
* @return {!Blockly.utils.Coordinate} Current translation of the surface.
*/
getSurfaceTranslation(): Blockly.utils.Coordinate;
/**
* Provide a reference to the drag group (primarily for
* BlockSvg.getRelativeToSurfaceXY).
* @return {?SVGElement} Drag surface group element.
*/
getGroup(): SVGElement;
/**
* Returns the SVG drag surface.
* @returns {?SVGElement} The SVG drag surface.
*/
getSvgRoot(): SVGElement;
/**
* Get the current blocks on the drag surface, if any (primarily
* for BlockSvg.getRelativeToSurfaceXY).
* @return {?Element} Drag surface block DOM element, or null if no blocks exist.
*/
getCurrentBlock(): Element;
/**
* Gets the translation of the child block surface
* This surface is in charge of keeping track of how much the workspace has
* moved.
* @return {!Blockly.utils.Coordinate} The amount the workspace has been moved.
*/
getWsTranslation(): Blockly.utils.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 {Element=} 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;
}
}
declare module Blockly {
class BlockDragger extends BlockDragger__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class BlockDragger__Class implements Blockly.IBlockDragger {
/**
* Class for a block dragger. It moves blocks around the workspace when they
* are being dragged by a mouse or touch.
* @param {!Blockly.BlockSvg} block The block to drag.
* @param {!Blockly.WorkspaceSvg} workspace The workspace to drag on.
* @constructor
* @implements {Blockly.IBlockDragger}
*/
constructor(block: Blockly.BlockSvg, workspace: Blockly.WorkspaceSvg);
/**
* The top block in the stack that is being dragged.
* @type {!Blockly.BlockSvg}
* @protected
*/
draggingBlock_: Blockly.BlockSvg;
/**
* The workspace on which the block is being dragged.
* @type {!Blockly.WorkspaceSvg}
* @protected
*/
workspace_: Blockly.WorkspaceSvg;
/**
* Object that keeps track of connections on dragged blocks.
* @type {!Blockly.InsertionMarkerManager}
* @protected
*/
draggedConnectionManager_: Blockly.InsertionMarkerManager;
/**
* Whether the block would be deleted if dropped immediately.
* @type {boolean}
* @protected
*/
wouldDeleteBlock_: boolean;
/**
* The location of the top left corner of the dragging block at the beginning
* of the drag in workspace coordinates.
* @type {!Blockly.utils.Coordinate}
* @protected
*/
startXY_: Blockly.utils.Coordinate;
/**
* A list of all of the icons (comment, warning, and mutator) that are
* on this block and its descendants. Moving an icon moves the bubble that
* extends from it if that bubble is open.
* @type {Array<!Object>}
* @protected
*/
dragIconData_: Object[];
/**
* Sever all links from this object.
* @package
*/
dispose(): void;
/**
* Start dragging a block. This includes moving it to the drag surface.
* @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
* moved from the position at mouse down, in pixel units.
* @param {boolean} healStack Whether or not to heal the stack after
* disconnecting.
* @public
*/
startDrag(currentDragDeltaXY: Blockly.utils.Coordinate, healStack: boolean): void;
/**
* Whether or not we should disconnect the block when a drag is started.
* @param {boolean} healStack Whether or not to heal the stack after
* disconnecting.
* @return {boolean} True to disconnect the block, false otherwise.
* @protected
*/
shouldDisconnect_(healStack: boolean): boolean;
/**
* Disconnects the block and moves it to a new location.
* @param {boolean} healStack Whether or not to heal the stack after
* disconnecting.
* @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
* moved from the position at mouse down, in pixel units.
* @protected
*/
disconnectBlock_(healStack: boolean, currentDragDeltaXY: Blockly.utils.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 {!Event} e The most recent move event.
* @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
* moved from the position at the start of the drag, in pixel units.
* @public
*/
drag(e: Event, currentDragDeltaXY: Blockly.utils.Coordinate): void;
/**
* Finish a block drag and put the block back on the workspace.
* @param {!Event} e The mouseup/touchend event.
* @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
* moved from the position at the start of the drag, in pixel units.
* @public
*/
endDrag(e: Event, currentDragDeltaXY: Blockly.utils.Coordinate): void;
/**
* Calculates the drag delta and new location values after a block is dragged.
* @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
* moved from the start of the drag, in pixel units.
* @return {{delta: !Blockly.utils.Coordinate, newLocation:
* !Blockly.utils.Coordinate}} New location after drag. delta is in
* workspace units. newLocation is the new coordinate where the block should
* end up.
* @protected
*/
getNewLocationAfterDrag_(currentDragDeltaXY: Blockly.utils.Coordinate): { delta: Blockly.utils.Coordinate; newLocation: Blockly.utils.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.
* @return {boolean} True if the block was deleted.
* @protected
*/
maybeDeleteBlock_(): boolean;
/**
* Updates the necessary information to place a block at a certain location.
* @param {!Blockly.utils.Coordinate} delta The change in location from where
* the block started the drag to where it ended the drag.
* @protected
*/
updateBlockAfterMove_(delta: Blockly.utils.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 {boolean} 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 {!Blockly.utils.Coordinate} pixelCoord A coordinate with x and y
* values in CSS pixel units.
* @return {!Blockly.utils.Coordinate} The input coordinate divided by the
* workspace scale.
* @protected
*/
pixelsToWorkspaceUnits_(pixelCoord: Blockly.utils.Coordinate): Blockly.utils.Coordinate;
/**
* Move all of the icons connected to this drag.
* @param {!Blockly.utils.Coordinate} dxy How far to move the icons from their
* original positions, in workspace units.
* @protected
*/
dragIcons_(dxy: Blockly.utils.Coordinate): void;
/**
* Get a list of the insertion markers that currently exist. Drags have 0, 1,
* or 2 insertion markers.
* @return {!Array<!Blockly.BlockSvg>} A possibly empty list of insertion
* marker blocks.
* @public
*/
getInsertionMarkers(): Blockly.BlockSvg[];
}
}
declare module Blockly {
class BlockSvg extends BlockSvg__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class BlockSvg__Class extends Blockly.Block__Class implements Blockly.IASTNodeLocationSvg, Blockly.IBoundedElement, Blockly.ICopyable, Blockly.IDraggable {
/**
* Class for a block's SVG representation.
* Not normally called directly, workspace.newBlock() is preferred.
* @param {!Blockly.WorkspaceSvg} workspace The block's workspace.
* @param {?string} prototypeName Name of the language object containing
* type-specific functions for this block.
* @param {string=} opt_id Optional ID. Use this ID if provided, otherwise
* create a new ID.
* @extends {Blockly.Block}
* @implements {Blockly.IASTNodeLocationSvg}
* @implements {Blockly.IBoundedElement}
* @implements {Blockly.ICopyable}
* @implements {Blockly.IDraggable}
* @constructor
*/
constructor(workspace: Blockly.WorkspaceSvg, prototypeName: string, opt_id?: string);
/**
* A block style object.
* @type {!Blockly.Theme.BlockStyle}
*/
style: Blockly.Theme.BlockStyle;
/**
* The renderer's path object.
* @type {Blockly.blockRendering.IPathObject}
* @package
*/
pathObject: Blockly.blockRendering.IPathObject;
/** @type {boolean} */
rendered: boolean;
/** @type {!Blockly.WorkspaceSvg} */
workspace: Blockly.WorkspaceSvg;
/** @type {Blockly.RenderedConnection} */
outputConnection: Blockly.RenderedConnection;
/** @type {Blockly.RenderedConnection} */
nextConnection: Blockly.RenderedConnection;
/** @type {Blockly.RenderedConnection} */
previousConnection: Blockly.RenderedConnection;
/**
* Height of this block, not including any statement blocks above or below.
* Height is in workspace units.
*/
height: any /*missing*/;
/**
* Width of this block, including any connected value blocks.
* Width is in workspace units.
*/
width: any /*missing*/;
/**
* An optional method called when a mutator dialog is first opened.
* This function must create and initialize a top-level block for the mutator
* dialog, and return it. This function should also populate this top-level
* block with any sub-blocks which are appropriate. This method must also be
* coupled with defining a `compose` method for the default mutation dialog
* button and UI to appear.
* @type {?function(Blockly.WorkspaceSvg):!Blockly.BlockSvg}
*/
decompose: { (_0: Blockly.WorkspaceSvg): Blockly.BlockSvg };
/**
* An optional method called when a mutator dialog saves its content.
* This function is called to modify the original block according to new
* settings. This method must also be coupled with defining a `decompose`
* method for the default mutation dialog button and UI to appear.
* @type {?function(!Blockly.BlockSvg)}
*/
compose: { (_0: Blockly.BlockSvg): any /*missing*/ };
/**
* An optional method for defining custom block context menu items.
* @type {?function(!Array<!Object>)}
*/
customContextMenu: { (_0: Object[]): any /*missing*/ };
/**
* An property used internally to reference the block's rendering debugger.
* @type {?Blockly.blockRendering.Debug}
* @package
*/
renderingDebugger: Blockly.blockRendering.Debug;
/**
* Create and initialize the SVG representation of the block.
* May be called more than once.
*/
initSvg(): void;
/**
* Get the secondary colour of a block.
* @return {?string} #RRGGBB string.
*/
getColourSecondary(): string;
/**
* Get the tertiary colour of a block.
* @return {?string} #RRGGBB string.
*/
getColourTertiary(): string;
/**
* Get the shadow colour of a block.
* @return {?string} #RRGGBB string.
* @deprecated Use style.colourSecondary. (2020 January 21)
*/
getColourShadow(): string;
/**
* Get the border colour(s) of a block.
* @return {{colourDark, colourLight, colourBorder}} An object containing
* colour values for the border(s) of the block. If the block is using a
* style the colourBorder will be defined and equal to the tertiary colour
* of the style (#RRGGBB string). Otherwise the colourDark and colourLight
* attributes will be defined (#RRGGBB strings).
* @deprecated Use style.colourTertiary. (2020 January 21)
*/
getColourBorder(): { colourDark: any /*missing*/; colourLight: any /*missing*/; colourBorder: any /*missing*/ };
/**
* Select this block. Highlight it visually.
*/
select(): void;
/**
* Unselect this block. Remove its highlighting.
*/
unselect(): void;
/**
* Block's mutator icon (if any).
* @type {?Blockly.Mutator}
*/
mutator: Blockly.Mutator;
/**
* Block's comment icon (if any).
* @type {?Blockly.Comment}
* @deprecated August 2019. Use getCommentIcon instead.
*/
comment: Blockly.Comment;
/**
* Block's warning icon (if any).
* @type {?Blockly.Warning}
*/
warning: Blockly.Warning;
/**
* Returns a list of mutator, comment, and warning icons.
* @return {!Array<!Blockly.Icon>} List of icons.
*/
getIcons(): Blockly.Icon[];
/**
* Return the coordinates of the top-left corner of this block relative to the
* drawing surface's origin (0,0), in workspace units.
* If the block is on the workspace, (0, 0) is the origin of the workspace
* coordinate system.
* This does not change with workspace scale.
* @return {!Blockly.utils.Coordinate} Object with .x and .y properties in
* workspace coordinates.
*/
getRelativeToSurfaceXY(): Blockly.utils.Coordinate;
/**
* Move a block by a relative offset.
* @param {number} dx Horizontal offset in workspace units.
* @param {number} dy Vertical offset in workspace units.
*/
moveBy(dx: number, dy: number): void;
/**
* Transforms a block by setting the translation on the transform attribute
* of the block's SVG.
* @param {number} x The x coordinate of the translation in workspace units.
* @param {number} y The y coordinate of the translation in workspace units.
*/
translate(x: number, y: number): void;
/**
* Move this block to its workspace's drag surface, accounting for positioning.
* Generally should be called at the same time as setDragging_(true).
* Does nothing if useDragSurface_ is false.
* @package
*/
moveToDragSurface(): void;
/**
* Move a block to a position.
* @param {Blockly.utils.Coordinate} xy The position to move to in workspace units.
*/
moveTo(xy: Blockly.utils.Coordinate): void;
/**
* Move this block back to the workspace block canvas.
* Generally should be called at the same time as setDragging_(false).
* Does nothing if useDragSurface_ is false.
* @param {!Blockly.utils.Coordinate} newXY The position the block should take on
* on the workspace canvas, in workspace coordinates.
* @package
*/
moveOffDragSurface(newXY: Blockly.utils.Coordinate): void;
/**
* Move this block during a drag, taking into account whether we are using a
* drag surface to translate blocks.
* This block must be a top-level block.
* @param {!Blockly.utils.Coordinate} newLoc The location to translate to, in
* workspace coordinates.
* @package
*/
moveDuringDrag(newLoc: Blockly.utils.Coordinate): void;
/**
* Snap this block to the nearest grid point.
*/
snapToGrid(): void;
/**
* Returns the coordinates of a bounding box describing the dimensions of this
* block and any blocks stacked below it.
* Coordinate system: workspace coordinates.
* @return {!Blockly.utils.Rect} Object with coordinates of the bounding box.
*/
getBoundingRectangle(): Blockly.utils.Rect;
/**
* Notify every input on this block to mark its fields as dirty.
* A dirty field is a field that needs to be re-rendered.
*/
markDirty(): void;
/**
* Set whether the block is collapsed or not.
* @param {boolean} collapsed True if collapsed.
*/
setCollapsed(collapsed: boolean): void;
/**
* Open the next (or previous) FieldTextInput.
* @param {!Blockly.Field} start Current field.
* @param {boolean} forward If true go forward, otherwise backward.
*/
tab(start: Blockly.Field, forward: boolean): void;
/**
* Load the block's help page in a new window.
* @package
*/
showHelp(): void;
/**
* Generate the context menu for this block.
* @protected
* @return {?Array<!Object>} Context menu options or null if no menu.
*/
generateContextMenu(): Object[];
/**
* Show the context menu for this block.
* @param {!Event} e Mouse event.
* @package
*/
showContextMenu(e: Event): void;
/**
* Move the connections for this block and all blocks attached under it.
* Also update any attached bubbles.
* @param {number} dx Horizontal offset from current location, in workspace
* units.
* @param {number} dy Vertical offset from current location, in workspace
* units.
* @package
*/
moveConnections(dx: number, dy: number): void;
/**
* Recursively adds or removes the dragging class to this node and its children.
* @param {boolean} adding True if adding, false if removing.
* @package
*/
setDragging(adding: boolean): void;
/**
* Set whether this block is movable or not.
* @param {boolean} movable True if movable.
*/
setMovable(movable: boolean): void;
/**
* Set whether this block is editable or not.
* @param {boolean} editable True if editable.
*/
setEditable(editable: boolean): void;
/**
* Set whether this block is a shadow block or not.
* @param {boolean} shadow True if a shadow.
*/
setShadow(shadow: boolean): void;
/**
* Set whether this block is an insertion marker block or not.
* Once set this cannot be unset.
* @param {boolean} insertionMarker True if an insertion marker.
* @package
*/
setInsertionMarker(insertionMarker: boolean): void;
/**
* Return the root node of the SVG or null if none exists.
* @return {!SVGGElement} The root SVG node (probably a group).
*/
getSvgRoot(): SVGGElement;
/**
* Dispose of this block.
* @param {boolean=} healStack If true, then try to heal any gap by connecting
* the next statement with the previous statement. Otherwise, dispose of
* all children of this block.
* @param {boolean=} animate If true, show a disposal animation and sound.
* @suppress {checkTypes}
*/
dispose(healStack?: boolean, animate?: boolean): void;
/**
* Encode a block for copying.
* @return {?Blockly.ICopyable.CopyData} Copy metadata, or null if the block is
* an insertion marker.
* @package
*/
toCopyData(): Blockly.ICopyable.CopyData;
/**
* Change the colour of a block.
* @package
*/
applyColour(): void;
/**
* Enable or disable a block.
*/
updateDisabled(): void;
/**
* Get the comment icon attached to this block, or null if the block has no
* comment.
* @return {?Blockly.Comment} The comment icon attached to this block, or null.
*/
getCommentIcon(): Blockly.Comment;
/**
* Set this block's comment text.
* @param {?string} text The text, or null to delete.
*/
setCommentText(text: string): void;
/**
* Set this block's warning text.
* @param {?string} text The text, or null to delete.
* @param {string=} opt_id An optional ID for the warning text to be able to
* maintain multiple warnings.
*/
setWarningText(text: string, opt_id?: string): void;
/**
* Give this block a mutator dialog.
* @param {?Blockly.Mutator} mutator A mutator dialog instance or null to remove.
*/
setMutator(mutator: Blockly.Mutator): void;
/**
* Set whether the block is enabled or not.
* @param {boolean} enabled True if enabled.
*/
setEnabled(enabled: boolean): void;
/**
* Set whether the block is highlighted or not. Block highlighting is
* often used to visually mark blocks currently being executed.
* @param {boolean} highlighted True if highlighted.
*/
setHighlighted(highlighted: boolean): void;
/**
* Select this block. Highlight it visually.
*/
addSelect(): void;
/**
* Unselect this block. Remove its highlighting.
*/
removeSelect(): void;
/**
* Update the cursor over this block by adding or removing a class.
* @param {boolean} enable True if the delete cursor should be shown, false
* otherwise.
* @package
*/
setDeleteStyle(enable: boolean): void;
/**
* Get the colour of a block.
* @return {string} #RRGGBB string.
*/
getColour(): string;
/**
* Change the colour of a block.
* @param {number|string} colour HSV hue value, or #RRGGBB string.
*/
setColour(colour: number|string): void;
/**
* Set the style and colour values of a block.
* @param {string} blockStyleName Name of the block style.
* @throws {Error} if the block style does not exist.
*/
setStyle(blockStyleName: string): void;
/**
* Move this block to the front of the visible workspace.
* <g> tags do not respect z-index so SVG renders them in the
* order that they are in the DOM. By placing this block first within the
* block group's <g>, it will render on top of any other blocks.
* @package
*/
bringToFront(): void;
/**
* Set whether this block can chain onto the bottom of another block.
* @param {boolean} newBoolean True if there can be a previous statement.
* @param {(string|Array<string>|null)=} opt_check Statement type or
* list of statement types. Null/undefined if any type could be connected.
*/
setPreviousStatement(newBoolean: boolean, opt_check?: string|string[]|any /*null*/): void;
/**
* Set whether another block can chain onto the bottom of this block.
* @param {boolean} newBoolean True if there can be a next statement.
* @param {(string|Array<string>|null)=} opt_check Statement type or
* list of statement types. Null/undefined if any type could be connected.
*/
setNextStatement(newBoolean: boolean, opt_check?: string|string[]|any /*null*/): void;
/**
* Set whether this block returns a value.
* @param {boolean} newBoolean True if there is an output.
* @param {(string|Array<string>|null)=} opt_check Returned type or list
* of returned types. Null or undefined if any type could be returned
* (e.g. variable get).
*/
setOutput(newBoolean: boolean, opt_check?: string|string[]|any /*null*/): void;
/**
* Set whether value inputs are arranged horizontally or vertically.
* @param {boolean} newBoolean True if inputs are horizontal.
*/
setInputsInline(newBoolean: boolean): void;
/**
* Remove an input from this block.
* @param {string} name The name of the input.
* @param {boolean=} opt_quiet True to prevent error if input is not present.
* @return {boolean} True if operation succeeds, false if input is not present and opt_quiet is true
* @throws {Error} if the input is not present and
* opt_quiet is not true.
*/
removeInput(name: string, opt_quiet?: boolean): boolean;
/**
* Move a numbered input to a different location on this block.
* @param {number} inputIndex Index of the input to move.
* @param {number} refIndex Index of input that should be after the moved input.
*/
moveNumberedInputBefore(inputIndex: number, refIndex: number): void;
/**
* Sets whether this block's connections are tracked in the database or not.
*
* Used by the deserializer to be more efficient. Setting a connection's
* tracked_ value to false keeps it from adding itself to the db when it
* gets its first moveTo call, saving expensive ops for later.
* @param {boolean} track If true, start tracking. If false, stop tracking.
* @package
*/
setConnectionTracking(track: boolean): void;
/**
* Returns connections originating from this block.
* @param {boolean} all If true, return all connections even hidden ones.
* Otherwise, for a non-rendered block return an empty list, and for a
* collapsed block don't return inputs connections.
* @return {!Array<!Blockly.RenderedConnection>} Array of connections.
* @package
*/
getConnections_(all: boolean): Blockly.RenderedConnection[];
/**
* Create a connection of the specified type.
* @param {number} type The type of the connection to create.
* @return {!Blockly.RenderedConnection} A new connection of the specified type.
* @protected
*/
makeConnection_(type: number): Blockly.RenderedConnection;
/**
* Bump unconnected blocks out of alignment. Two blocks which aren't actually
* connected should not coincidentally line up on screen.
*/
bumpNeighbours(): void;
/**
* Schedule snapping to grid and bumping neighbours to occur after a brief
* delay.
* @package
*/
scheduleSnapAndBump(): void;
/**
* Position a block so that it doesn't move the target block when connected.
* The block to position is usually either the first block in a dragged stack or
* an insertion marker.
* @param {!Blockly.RenderedConnection} sourceConnection The connection on the
* moving block's stack.
* @param {!Blockly.RenderedConnection} targetConnection The connection that
* should stay stationary as this block is positioned.
* @package
*/
positionNearConnection(sourceConnection: Blockly.RenderedConnection, targetConnection: Blockly.RenderedConnection): void;
/**
* Lays out and reflows a block based on its contents and settings.
* @param {boolean=} opt_bubble If false, just render this block.
* If true, also render block's parent, grandparent, etc. Defaults to true.
*/
render(opt_bubble?: boolean): void;
/**
* Redraw any attached marker or cursor svgs if needed.
* @protected
*/
updateMarkers_(): void;
/**
* Add the cursor SVG to this block's SVG group.
* @param {SVGElement} cursorSvg The SVG root of the cursor to be added to the
* block SVG group.
* @package
*/
setCursorSvg(cursorSvg: SVGElement): void;
/**
* Add the marker SVG to this block's SVG group.
* @param {SVGElement} markerSvg The SVG root of the marker to be added to the
* block SVG group.
* @package
*/
setMarkerSvg(markerSvg: SVGElement): void;
/**
* Returns a bounding box describing the dimensions of this block
* and any blocks stacked below it.
* @return {!{height: number, width: number}} Object with height and width
* properties in workspace units.
* @package
*/
getHeightWidth(): { height: number; width: number };
/**
* Visual effect to show that if the dragging block is dropped, this block will
* be replaced. If a shadow block, it will disappear. Otherwise it will bump.
* @param {boolean} add True if highlighting should be added.
* @package
*/
fadeForReplacement(add: boolean): void;
/**
* Visual effect to show that if the dragging block is dropped it will connect
* to this input.
* @param {Blockly.Connection} conn The connection on the input to highlight.
* @param {boolean} add True if highlighting should be added.
* @package
*/
highlightShapeForInput(conn: Blockly.Connection, add: boolean): void;
}
}
declare module Blockly.BlockSvg {
/**
* Constant for identifying rows that are to be rendered inline.
* Don't collide with Blockly.inputTypes.
* @const
*/
var INLINE: any /*missing*/;
/**
* ID to give the "collapsed warnings" warning. Allows us to remove the
* "collapsed warnings" warning without removing any warnings that belong to
* the block.
* @type {string}
* @const
*/
var COLLAPSED_WARNING_ID: string;
}
declare module Blockly {
/**
* Blockly core version.
* This constant is overridden by the build script (npm run build) to the value
* of the version in package.json. This is done by the Closure Compiler in the
* buildCompressed gulp task.
* For local builds, you can pass --define='Blockly.VERSION=X.Y.Z' to the
* compiler to override this constant.
* @define {string}
*/
var VERSION: any /*missing*/;
/**
* The main workspace most recently used.
* Set by Blockly.WorkspaceSvg.prototype.markFocused
* @type {Blockly.Workspace}
*/
var mainWorkspace: Blockly.Workspace;
/**
* Currently selected block.
* @type {?Blockly.ICopyable}
*/
var selected: Blockly.ICopyable;
/**
* All of the connections on blocks that are currently being dragged.
* @type {!Array<!Blockly.Connection>}
* @package
*/
var draggingConnections: Blockly.Connection[];
/**
* Container element to render the WidgetDiv, DropDownDiv and Tooltip.
* @type {?Element}
* @package
*/
var parentContainer: Element;
/**
* Returns the dimensions of the specified SVG image.
* @param {!SVGElement} svg SVG image.
* @return {!Blockly.utils.Size} Contains width and height properties.
* @deprecated Use workspace.setCachedParentSvgSize. (2021 March 5)
*/
function svgSize(svg: SVGElement): Blockly.utils.Size;
/**
* Size the workspace when the contents change. This also updates
* scrollbars accordingly.
* @param {!Blockly.WorkspaceSvg} workspace The workspace to resize.
*/
function resizeSvgContents(workspace: Blockly.WorkspaceSvg): void;
/**
* Size the SVG image to completely fill its container. Call this when the view
* actually changes sizes (e.g. on a window resize/device orientation change).
* See Blockly.resizeSvgContents to resize the workspace when the contents
* change (e.g. when a block is added or removed).
* Record the height/width of the SVG image.
* @param {!Blockly.WorkspaceSvg} workspace Any workspace in the SVG.
*/
function svgResize(workspace: Blockly.WorkspaceSvg): void;
/**
* Handle a key-down on SVG drawing surface. Does nothing if the main workspace
* is not visible.
* @param {!KeyboardEvent} e Key down event.
* @package
*/
function onKeyDown(e: KeyboardEvent): void;
/**
* Delete the given block.
* @param {!Blockly.BlockSvg} selected The block to delete.
* @package
*/
function deleteBlock(selected: Blockly.BlockSvg): void;
/**
* Copy a block or workspace comment onto the local clipboard.
* @param {!Blockly.ICopyable} toCopy Block or Workspace Comment to be copied.
* @package
*/
function copy(toCopy: Blockly.ICopyable): void;
/**
* Paste a block or workspace comment on to the main workspace.
* @return {boolean} True if the paste was successful, false otherwise.
* @package
*/
function paste(): boolean;
/**
* Duplicate this block and its children, or a workspace comment.
* @param {!Blockly.ICopyable} toDuplicate Block or Workspace Comment to be
* copied.
* @package
*/
function duplicate(toDuplicate: Blockly.ICopyable): void;
/**
* Close tooltips, context menus, dropdown selections, etc.
* @param {boolean=} opt_onlyClosePopups Whether only popups should be closed.
*/
function hideChaff(opt_onlyClosePopups?: boolean): void;
/**
* Returns the main workspace. Returns the last used main workspace (based on
* focus). Try not to use this function, particularly if there are multiple
* Blockly instances on a page.
* @return {!Blockly.Workspace} The main workspace.
*/
function getMainWorkspace(): Blockly.Workspace;
/**
* Wrapper to window.alert() that app developers may override to
* provide alternatives to the modal browser window.
* @param {string} message The message to display to the user.
* @param {function()=} opt_callback The callback when the alert is dismissed.
*/
function alert(message: string, opt_callback?: { (): any /*missing*/ }): void;
/**
* Wrapper to window.confirm() that app developers may override to
* provide alternatives to the modal browser window.
* @param {string} message The message to display to the user.
* @param {!function(boolean)} callback The callback for handling user response.
*/
function confirm(message: string, callback: { (_0: boolean): any /*missing*/ }): void;
/**
* 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.
* @param {string} message The message to display to the user.
* @param {string} defaultValue The value to initialize the prompt with.
* @param {!function(?string)} callback The callback for handling user response.
*/
function prompt(message: string, defaultValue: string, callback: { (_0: string): any /*missing*/ }): void;
/**
* Define blocks from an array of JSON block definitions, as might be generated
* by the Blockly Developer Tools.
* @param {!Array<!Object>} jsonArray An array of JSON block definitions.
*/
function defineBlocksWithJsonArray(jsonArray: Object[]): void;
/**
* Is the given string a number (includes negative and decimals).
* @param {string} str Input string.
* @return {boolean} True if number, false otherwise.
*/
function isNumber(str: string): boolean;
/**
* Convert a hue (HSV model) into an RGB hex triplet.
* @param {number} hue Hue on a colour wheel (0-360).
* @return {string} RGB code, e.g. '#5ba65b'.
*/
function hueToHex(hue: number): string;
/**
* Checks old colour constants are not overwritten by the host application.
* If a constant is overwritten, it prints a console warning directing the
* developer to use the equivalent Msg constant.
* @package
*/
function checkBlockColourConstants(): void;
/**
* Set the parent container. This is the container element that the WidgetDiv,
* DropDownDiv, and Tooltip are rendered into the first time `Blockly.inject`
* is called.
* This method is a NOP if called after the first ``Blockly.inject``.
* @param {!Element} container The container element.
*/
function setParentContainer(container: Element): void;
/**
* @see Blockly.browserEvents.bind
*/
var bindEvent_: any /*missing*/;
/**
* @see Blockly.browserEvents.unbind
*/
var unbindEvent_: any /*missing*/;
/**
* @see Blockly.browserEvents.conditionalBind
*/
var bindEventWithChecks_: any /*missing*/;
/**
* @see Blockly.constants.ALIGN.LEFT
*/
var ALIGN_LEFT: any /*missing*/;
/**
* @see Blockly.constants.ALIGN.CENTRE
*/
var ALIGN_CENTRE: any /*missing*/;
/**
* @see Blockly.constants.ALIGN.RIGHT
*/
var ALIGN_RIGHT: any /*missing*/;
/**
* @see Blockly.connectionTypes.INPUT_VALUE
*/
var INPUT_VALUE: any /*missing*/;
/**
* @see Blockly.connectionTypes.OUTPUT_VALUE
*/
var OUTPUT_VALUE: any /*missing*/;
/**
* @see Blockly.connectionTypes.NEXT_STATEMENT
*/
var NEXT_STATEMENT: any /*missing*/;
/**
* @see Blockly.connectionTypes.PREVIOUS_STATEMENT
*/
var PREVIOUS_STATEMENT: any /*missing*/;
/**
* @see Blockly.inputTypes.DUMMY_INPUT
*/
var DUMMY_INPUT: any /*missing*/;
/**
* @see Blockly.utils.toolbox.Position.TOP
*/
var TOOLBOX_AT_TOP: any /*missing*/;
/**
* @see Blockly.utils.toolbox.Position.BOTTOM
*/
var TOOLBOX_AT_BOTTOM: any /*missing*/;
/**
* @see Blockly.utils.toolbox.Position.LEFT
*/
var TOOLBOX_AT_LEFT: any /*missing*/;
/**
* @see Blockly.utils.toolbox.Position.RIGHT
*/
var TOOLBOX_AT_RIGHT: any /*missing*/;
}
declare module Blockly {
/**
* A mapping of block type names to block prototype objects.
* @type {!Object<string,Object>}
*/
var Blocks: { [key: string]: Object };
}
declare module Blockly.browserEvents {
/**
* Blockly opaque event data used to unbind events when using
* `Blockly.browserEvents.bind` and
* `Blockly.browserEvents.conditionalBind`.
* @typedef {!Array<!Array>}
*/
interface Data extends Array<any[]> { }
/**
* Bind an event handler that can be ignored if it is not part of the active
* touch stream.
* Use this for events that either start or continue a multi-part gesture (e.g.
* mousedown or mousemove, which may be part of a drag or click).
* @param {!EventTarget} node Node upon which to listen.
* @param {string} name Event name to listen to (e.g. 'mousedown').
* @param {?Object} thisObject The value of 'this' in the function.
* @param {!Function} func Function to call when event is triggered.
* @param {boolean=} opt_noCaptureIdentifier True if triggering on this event
* should not block execution of other event handlers on this touch or
* other simultaneous touches. False by default.
* @param {boolean=} opt_noPreventDefault True if triggering on this event
* should prevent the default handler. False by default. If
* opt_noPreventDefault is provided, opt_noCaptureIdentifier must also be
* provided.
* @return {!Blockly.browserEvents.Data} Opaque data that can be passed to
* unbindEvent_.
* @public
*/
function conditionalBind(node: EventTarget, name: string, thisObject: Object, func: Function, opt_noCaptureIdentifier?: boolean, opt_noPreventDefault?: boolean): Blockly.browserEvents.Data;
/**
* Bind an event handler that should be called regardless of whether it is part
* of the active touch stream.
* Use this for events that are not part of a multi-part gesture (e.g.
* mouseover for tooltips).
* @param {!EventTarget} node Node upon which to listen.
* @param {string} name Event name to listen to (e.g. 'mousedown').
* @param {?Object} thisObject The value of 'this' in the function.
* @param {!Function} func Function to call when event is triggered.
* @return {!Blockly.browserEvents.Data} Opaque data that can be passed to
* unbindEvent_.
* @public
*/
function bind(node: EventTarget, name: string, thisObject: Object, func: Function): Blockly.browserEvents.Data;
/**
* Unbind one or more events event from a function call.
* @param {!Blockly.browserEvents.Data} bindData Opaque data from bindEvent_.
* This list is emptied during the course of calling this function.
* @return {!Function} The function call.
* @public
*/
function unbind(bindData: Blockly.browserEvents.Data): Function;
}
declare module Blockly {
class Bubble extends Bubble__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Bubble__Class implements Blockly.IBubble {
/**
* Class for UI bubble.
* @param {!Blockly.WorkspaceSvg} workspace The workspace on which to draw the
* bubble.
* @param {!Element} content SVG content for the bubble.
* @param {!Element} shape SVG element to avoid eclipsing.
* @param {!Blockly.utils.Coordinate} anchorXY Absolute position of bubble's
* anchor point.
* @param {?number} bubbleWidth Width of bubble, or null if not resizable.
* @param {?number} bubbleHeight Height of bubble, or null if not resizable.
* @implements {Blockly.IBubble}
* @constructor
*/
constructor(workspace: Blockly.WorkspaceSvg, content: Element, shape: Element, anchorXY: Blockly.utils.Coordinate, bubbleWidth: number, bubbleHeight: number);
/**
* Describes whether this bubble has been disposed of (nodes and event
* listeners removed from the page) or not.
* @type {boolean}
* @package
*/
disposed: boolean;
/**
* Return the root node of the bubble's SVG group.
* @return {!SVGElement} The root SVG node of the bubble's group.
*/
getSvgRoot(): SVGElement;
/**
* Expose the block's ID on the bubble's top-level SVG group.
* @param {string} id ID of block.
*/
setSvgId(id: string): void;
/**
* Show the context menu for this bubble.
* @param {!Event} _e Mouse event.
* @package
*/
showContextMenu(_e: Event): void;
/**
* Get whether this bubble is deletable or not.
* @return {boolean} True if deletable.
* @package
*/
isDeletable(): boolean;
/**
* Update the style of this bubble when it is dragged over a delete area.
* @param {boolean} _enable True if the bubble is about to be deleted, false
* otherwise.
*/
setDeleteStyle(_enable: boolean): void;
/**
* Register a function as a callback event for when the bubble is resized.
* @param {!Function} callback The function to call on resize.
*/
registerResizeEvent(callback: Function): void;
/**
* Register a function as a callback event for when the bubble is moved.
* @param {!Function} callback The function to call on move.
*/
registerMoveEvent(callback: Function): void;
/**
* Move this bubble to the top of the stack.
* @return {boolean} Whether or not the bubble has been moved.
* @package
*/
promote(): boolean;
/**
* Notification that the anchor has moved.
* Update the arrow and bubble accordingly.
* @param {!Blockly.utils.Coordinate} xy Absolute location.
*/
setAnchorLocation(xy: Blockly.utils.Coordinate): void;
/**
* Move the bubble group to the specified location in workspace coordinates.
* @param {number} x The x position to move to.
* @param {number} y The y position to move to.
* @package
*/
moveTo(x: number, y: number): void;
/**
* Triggers a move callback if one exists at the end of a drag.
* @param {boolean} adding True if adding, false if removing.
* @package
*/
setDragging(adding: boolean): void;
/**
* Get the dimensions of this bubble.
* @return {!Blockly.utils.Size} The height and width of the bubble.
*/
getBubbleSize(): Blockly.utils.Size;
/**
* Size this bubble.
* @param {number} width Width of the bubble.
* @param {number} height Height of the bubble.
*/
setBubbleSize(width: number, height: number): void;
/**
* Change the colour of a bubble.
* @param {string} hexColour Hex code of colour.
*/
setColour(hexColour: string): void;
/**
* Dispose of this bubble.
*/
dispose(): void;
/**
* Move this bubble during a drag, taking into account whether or not there is
* a drag surface.
* @param {Blockly.BlockDragSurfaceSvg} dragSurface The surface that carries
* rendered items during a drag, or null if no drag surface is in use.
* @param {!Blockly.utils.Coordinate} newLoc The location to translate to, in
* workspace coordinates.
* @package
*/
moveDuringDrag(dragSurface: Blockly.BlockDragSurfaceSvg, newLoc: Blockly.utils.Coordinate): void;
/**
* Return the coordinates of the top-left corner of this bubble's body relative
* to the drawing surface's origin (0,0), in workspace units.
* @return {!Blockly.utils.Coordinate} Object with .x and .y properties.
*/
getRelativeToSurfaceXY(): Blockly.utils.Coordinate;
/**
* Set whether auto-layout of this bubble is enabled. The first time a bubble
* is shown it positions itself to not cover any blocks. Once a user has
* dragged it to reposition, it renders where the user put it.
* @param {boolean} enable True if auto-layout should be enabled, false
* otherwise.
* @package
*/
setAutoLayout(enable: boolean): void;
}
}
declare module Blockly.Bubble {
/**
* Width of the border around the bubble.
*/
var BORDER_WIDTH: any /*missing*/;
/**
* Determines the thickness of the base of the arrow in relation to the size
* of the bubble. Higher numbers result in thinner arrows.
*/
var ARROW_THICKNESS: any /*missing*/;
/**
* The number of degrees that the arrow bends counter-clockwise.
*/
var ARROW_ANGLE: any /*missing*/;
/**
* The sharpness of the arrow's bend. Higher numbers result in smoother arrows.
*/
var ARROW_BEND: any /*missing*/;
/**
* Distance between arrow point and anchor point.
*/
var ANCHOR_RADIUS: any /*missing*/;
/**
* Create the text for a non editable bubble.
* @param {string} text The text to display.
* @return {!SVGTextElement} The top-level node of the text.
* @package
*/
function textToDom(text: string): SVGTextElement;
/**
* Creates a bubble that can not be edited.
* @param {!SVGTextElement} paragraphElement The text element for the non
* editable bubble.
* @param {!Blockly.BlockSvg} block The block that the bubble is attached to.
* @param {!Blockly.utils.Coordinate} iconXY The coordinate of the icon.
* @return {!Blockly.Bubble} The non editable bubble.
* @package
*/
function createNonEditableBubble(paragraphElement: SVGTextElement, block: Blockly.BlockSvg, iconXY: Blockly.utils.Coordinate): Blockly.Bubble;
}
declare module Blockly {
class BubbleDragger extends BubbleDragger__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class BubbleDragger__Class {
/**
* 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.
* @param {!Blockly.IBubble} bubble The item on the bubble canvas to drag.
* @param {!Blockly.WorkspaceSvg} workspace The workspace to drag on.
* @constructor
*/
constructor(bubble: Blockly.IBubble, workspace: Blockly.WorkspaceSvg);
/**
* Sever all links from this object.
* @package
* @suppress {checkTypes}
*/
dispose(): void;
/**
* Start dragging a bubble. This includes moving it to the drag surface.
* @package
*/
startBubbleDrag(): void;
/**
* Execute a step of bubble dragging, based on the given event. Update the
* display accordingly.
* @param {!Event} e The most recent move event.
* @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
* moved from the position at the start of the drag, in pixel units.
* @package
*/
dragBubble(e: Event, currentDragDeltaXY: Blockly.utils.Coordinate): void;
/**
* Finish a bubble drag and put the bubble back on the workspace.
* @param {!Event} e The mouseup/touchend event.
* @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
* moved from the position at the start of the drag, in pixel units.
* @package
*/
endBubbleDrag(e: Event, currentDragDeltaXY: Blockly.utils.Coordinate): void;
}
}
declare module Blockly {
class Comment extends Comment__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Comment__Class extends Blockly.Icon__Class {
/**
* Class for a comment.
* @param {!Blockly.Block} block The block associated with this comment.
* @extends {Blockly.Icon}
* @constructor
*/
constructor(block: Blockly.Block);
/**
* Draw the comment icon.
* @param {!Element} group The icon group.
* @protected
*/
drawIcon_(group: Element): void;
/**
* Show or hide the comment bubble.
* @param {boolean} visible True if the bubble should be visible.
*/
setVisible(visible: boolean): void;
/**
* Get the dimensions of this comment's bubble.
* @return {Blockly.utils.Size} Object with width and height properties.
*/
getBubbleSize(): Blockly.utils.Size;
/**
* Size this comment's bubble.
* @param {number} width Width of the bubble.
* @param {number} height Height of the bubble.
*/
setBubbleSize(width: number, height: number): void;
/**
* Update the comment's view to match the model.
* @package
*/
updateText(): void;
/**
* Dispose of this comment.
*
* If you want to receive a comment "delete" event (newValue: null), then this
* should not be called directly. Instead call block.setCommentText(null);
*/
dispose(): void;
}
}
declare module Blockly {
class ComponentManager extends ComponentManager__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class ComponentManager__Class {
/**
* Manager for all items registered with the workspace.
* @constructor
*/
constructor();
/**
* Adds a component.
* @param {!Blockly.ComponentManager.ComponentDatum} componentInfo The data for
* the component to register.
* @param {boolean=} opt_allowOverrides True to prevent an error when overriding
* an already registered item.
*/
addComponent(componentInfo: Blockly.ComponentManager.ComponentDatum, opt_allowOverrides?: boolean): void;
/**
* Removes a component.
* @param {string} id The ID of the component to remove.
*/
removeComponent(id: string): void;
/**
* Adds a capability to a existing registered component.
* @param {string} id The ID of the component to add the capability to.
* @param {string|!Blockly.ComponentManager.Capability<T>} capability The
* capability to add.
* @template T
*/
addCapability<T>(id: string, capability: string|Blockly.ComponentManager.Capability<T>): void;
/**
* Removes a capability from an existing registered component.
* @param {string} id The ID of the component to remove the capability from.
* @param {string|!Blockly.ComponentManager.Capability<T>} capability The
* capability to remove.
* @template T
*/
removeCapability<T>(id: string, capability: string|Blockly.ComponentManager.Capability<T>): void;
/**
* Returns whether the component with this id has the specified capability.
* @param {string} id The ID of the component to check.
* @param {string|!Blockly.ComponentManager.Capability<T>} capability The
* capability to check for.
* @return {boolean} Whether the component has the capability.
* @template T
*/
hasCapability<T>(id: string, capability: string|Blockly.ComponentManager.Capability<T>): boolean;
/**
* Gets the component with the given ID.
* @param {string} id The ID of the component to get.
* @return {!Blockly.IComponent|undefined} The component with the given name
* or undefined if not found.
*/
getComponent(id: string): Blockly.IComponent|any /*undefined*/;
/**
* Gets all the components with the specified capability.
* @param {string|!Blockly.ComponentManager.Capability<T>
* } capability The capability of the component.
* @param {boolean} sorted Whether to return list ordered by weights.
* @return {!Array<T>} The components that match the specified capability.
* @template T
*/
getComponents<T>(capability: string|Blockly.ComponentManager.Capability<T>, sorted: boolean): T[];
}
}
declare module Blockly.ComponentManager {
class Capability<T> extends Capability__Class<T> { }
/** Fake class which should be extended to avoid inheriting static properties */
class Capability__Class<T> {
/**
* A name with the capability of the element stored in the generic.
* @param {string} name The name of the component capability.
* @constructor
* @template T
*/
constructor(name: string);
}
/**
* An object storing component information.
* @typedef {{
* component: !Blockly.IComponent,
* capabilities: (
* !Array<string|!Blockly.ComponentManager.Capability<!Blockly.IComponent>>
* ),
* weight: number
* }}
*/
interface ComponentDatum {
component: Blockly.IComponent;
capabilities: string|Blockly.ComponentManager.Capability<Blockly.IComponent>[];
weight: number
}
}
declare module Blockly.ComponentManager.Capability {
/** @type {!Blockly.ComponentManager.Capability<!Blockly.IPositionable>} */
var POSITIONABLE: Blockly.ComponentManager.Capability<Blockly.IPositionable>;
/** @type {!Blockly.ComponentManager.Capability<!Blockly.IDragTarget>} */
var DRAG_TARGET: Blockly.ComponentManager.Capability<Blockly.IDragTarget>;
/** @type {!Blockly.ComponentManager.Capability<!Blockly.IDeleteArea>} */
var DELETE_AREA: Blockly.ComponentManager.Capability<Blockly.IDeleteArea>;
/** @type {!Blockly.ComponentManager.Capability<!Blockly.IAutoHideable>} */
var AUTOHIDEABLE: Blockly.ComponentManager.Capability<Blockly.IAutoHideable>;
}
declare module Blockly {
class Connection extends Connection__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Connection__Class implements Blockly.IASTNodeLocationWithBlock {
/**
* Class for a connection between blocks.
* @param {!Blockly.Block} source The block establishing this connection.
* @param {number} type The type of the connection.
* @constructor
* @implements {Blockly.IASTNodeLocationWithBlock}
*/
constructor(source: Blockly.Block, type: number);
/**
* @type {!Blockly.Block}
* @protected
*/
sourceBlock_: Blockly.Block;
/** @type {number} */
type: number;
/**
* Connection this connection connects to. Null if not connected.
* @type {Blockly.Connection}
*/
targetConnection: Blockly.Connection;
/**
* Has this connection been disposed of?
* @type {boolean}
* @package
*/
disposed: boolean;
/**
* Horizontal location of this connection.
* @type {number}
* @package
*/
x: number;
/**
* Vertical location of this connection.
* @type {number}
* @package
*/
y: number;
/**
* Connect two connections together. This is the connection on the superior
* block.
* @param {!Blockly.Connection} childConnection Connection on inferior block.
* @protected
*/
connect_(childConnection: Blockly.Connection): void;
/**
* Dispose of this connection and deal with connected blocks.
* @package
*/
dispose(): void;
/**
* Get the source block for this connection.
* @return {!Blockly.Block} The source block.
*/
getSourceBlock(): Blockly.Block;
/**
* Does the connection belong to a superior block (higher in the source stack)?
* @return {boolean} True if connection faces down or right.
*/
isSuperior(): boolean;
/**
* Is the connection connected?
* @return {boolean} True if connection is connected to another connection.
*/
isConnected(): boolean;
/**
* Checks whether the current connection can connect with the target
* connection.
* @param {Blockly.Connection} target Connection to check compatibility with.
* @return {number} Blockly.Connection.CAN_CONNECT if the connection is legal,
* an error code otherwise.
* @deprecated July 2020. Will be deleted July 2021. Use the workspace's
* connectionChecker instead.
*/
canConnectWithReason(target: Blockly.Connection): number;
/**
* Checks whether the current connection and target connection are compatible
* and throws an exception if they are not.
* @param {Blockly.Connection} target The connection to check compatibility
* with.
* @package
* @deprecated July 2020. Will be deleted July 2021. Use the workspace's
* connectionChecker instead.
*/
checkConnection(target: Blockly.Connection): void;
/**
* Get the workspace's connection type checker object.
* @return {!Blockly.IConnectionChecker} The connection type checker for the
* source block's workspace.
* @package
*/
getConnectionChecker(): Blockly.IConnectionChecker;
/**
* Check if the two connections can be dragged to connect to each other.
* @param {!Blockly.Connection} candidate A nearby connection to check.
* @return {boolean} True if the connection is allowed, false otherwise.
* @deprecated July 2020. Will be deleted July 2021. Use the workspace's
* connectionChecker instead.
*/
isConnectionAllowed(candidate: Blockly.Connection): boolean;
/**
* Called when an attempted connection fails. NOP by default (i.e. for headless
* workspaces).
* @param {!Blockly.Connection} _otherConnection Connection that this connection
* failed to connect to.
* @package
*/
onFailedConnect(_otherConnection: Blockly.Connection): void;
/**
* Connect this connection to another connection.
* @param {!Blockly.Connection} otherConnection Connection to connect to.
*/
connect(otherConnection: Blockly.Connection): void;
/**
* Disconnect this connection.
*/
disconnect(): void;
/**
* Disconnect two blocks that are connected by this connection.
* @param {!Blockly.Block} parentBlock The superior block.
* @param {!Blockly.Block} childBlock The inferior block.
* @protected
*/
disconnectInternal_(parentBlock: Blockly.Block, childBlock: Blockly.Block): void;
/**
* Respawn the shadow block if there was one connected to the this connection.
* @protected
*/
respawnShadow_(): void;
/**
* Returns the block that this connection connects to.
* @return {?Blockly.Block} The connected block or null if none is connected.
*/
targetBlock(): Blockly.Block;
/**
* Is this connection compatible with another connection with respect to the
* value type system. E.g. square_root("Hello") is not compatible.
* @param {!Blockly.Connection} otherConnection Connection to compare against.
* @return {boolean} True if the connections share a type.
* @deprecated July 2020. Will be deleted July 2021. Use the workspace's
* connectionChecker instead.
*/
checkType(otherConnection: Blockly.Connection): boolean;
/**
* Function to be called when this connection's compatible types have changed.
* @protected
*/
onCheckChanged_(): void;
/**
* Change a connection's compatibility.
* @param {?(string|!Array<string>)} check Compatible value type or list of
* value types. Null if all types are compatible.
* @return {!Blockly.Connection} The connection being modified
* (to allow chaining).
*/
setCheck(check: string|string[]): Blockly.Connection;
/**
* Get a connection's compatibility.
* @return {?Array} List of compatible value types.
* Null if all types are compatible.
* @public
*/
getCheck(): any[];
/**
* Changes the connection's shadow block.
* @param {?Element} shadow DOM representation of a block or null.
*/
setShadowDom(shadow: Element): void;
/**
* Returns the xml representation of the connection's shadow block.
* @param {boolean=} returnCurrent If true, and the shadow block is currently
* attached to this connection, this serializes the state of that block
* and returns it (so that field values are correct). Otherwise the saved
* shadowDom is just returned.
* @return {?Element} Shadow DOM representation of a block or null.
*/
getShadowDom(returnCurrent?: boolean): Element;
/**
* Find all nearby compatible connections to this connection.
* Type checking does not apply, since this function is used for bumping.
*
* Headless configurations (the default) do not have neighboring connection,
* and always return an empty list (the default).
* {@link Blockly.RenderedConnection} overrides this behavior with a list
* computed from the rendered positioning.
* @param {number} _maxLimit The maximum radius to another connection.
* @return {!Array<!Blockly.Connection>} List of connections.
* @package
*/
neighbours(_maxLimit: number): Blockly.Connection[];
/**
* Get the parent input of a connection.
* @return {?Blockly.Input} The input that the connection belongs to or null if
* no parent exists.
* @package
*/
getParentInput(): Blockly.Input;
/**
* This method returns a string describing this Connection in developer terms
* (English only). Intended to on be used in console logs and errors.
* @return {string} The description.
*/
toString(): string;
}
}
declare module Blockly.Connection {
/**
* Constants for checking whether two connections are compatible.
*/
var CAN_CONNECT: any /*missing*/;
/**
* Returns the connection (starting at the startBlock) which will accept
* the given connection. This includes compatible connection types and
* connection checks.
* @param {!Blockly.Block} startBlock The block on which to start the search.
* @param {!Blockly.Connection} orphanConnection The connection that is looking
* for a home.
* @return {?Blockly.Connection} The suitable connection point on the chain of
* blocks, or null.
*/
function getConnectionForOrphanedConnection(startBlock: Blockly.Block, orphanConnection: Blockly.Connection): Blockly.Connection;
}
declare module Blockly {
class ConnectionChecker extends ConnectionChecker__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class ConnectionChecker__Class implements Blockly.IConnectionChecker {
/**
* Class for connection type checking logic.
* @implements {Blockly.IConnectionChecker}
* @constructor
*/
constructor();
/**
* Check whether the current connection can connect with the target
* connection.
* @param {Blockly.Connection} a Connection to check compatibility with.
* @param {Blockly.Connection} b Connection to check compatibility with.
* @param {boolean} isDragging True if the connection is being made by dragging
* a block.
* @param {number=} opt_distance The max allowable distance between the
* connections for drag checks.
* @return {boolean} Whether the connection is legal.
* @public
*/
canConnect(a: Blockly.Connection, b: Blockly.Connection, isDragging: boolean, opt_distance?: number): boolean;
/**
* Checks whether the current connection can connect with the target
* connection, and return an error code if there are problems.
* @param {Blockly.Connection} a Connection to check compatibility with.
* @param {Blockly.Connection} b Connection to check compatibility with.
* @param {boolean} isDragging True if the connection is being made by dragging
* a block.
* @param {number=} opt_distance The max allowable distance between the
* connections for drag checks.
* @return {number} Blockly.Connection.CAN_CONNECT if the connection is legal,
* an error code otherwise.
* @public
*/
canConnectWithReason(a: Blockly.Connection, b: Blockly.Connection, isDragging: boolean, opt_distance?: number): number;
/**
* Helper method that translates a connection error code into a string.
* @param {number} errorCode The error code.
* @param {Blockly.Connection} a One of the two connections being checked.
* @param {Blockly.Connection} b The second of the two connections being
* checked.
* @return {string} A developer-readable error string.
* @public
*/
getErrorMessage(errorCode: number, a: Blockly.Connection, b: Blockly.Connection): string;
/**
* Check that connecting the given connections is safe, meaning that it would
* not break any of Blockly's basic assumptions (e.g. no self connections).
* @param {Blockly.Connection} a The first of the connections to check.
* @param {Blockly.Connection} b The second of the connections to check.
* @return {number} An enum with the reason this connection is safe or unsafe.
* @public
*/
doSafetyChecks(a: Blockly.Connection, b: Blockly.Connection): number;
/**
* Check whether this connection is compatible with another connection with
* respect to the value type system. E.g. square_root("Hello") is not
* compatible.
* @param {!Blockly.Connection} a Connection to compare.
* @param {!Blockly.Connection} b Connection to compare against.
* @return {boolean} True if the connections share a type.
* @public
*/
doTypeChecks(a: Blockly.Connection, b: Blockly.Connection): boolean;
/**
* Check whether this connection can be made by dragging.
* @param {!Blockly.RenderedConnection} a Connection to compare.
* @param {!Blockly.RenderedConnection} b Connection to compare against.
* @param {number} distance The maximum allowable distance between connections.
* @return {boolean} True if the connection is allowed during a drag.
* @public
*/
doDragChecks(a: Blockly.RenderedConnection, b: Blockly.RenderedConnection, distance: number): boolean;
/**
* Helper function for drag checking.
* @param {!Blockly.Connection} a The connection to check, which must be a
* statement input or next connection.
* @param {!Blockly.Connection} b A nearby connection to check, which
* must be a previous connection.
* @return {boolean} True if the connection is allowed, false otherwise.
* @protected
*/
canConnectToPrevious_(a: Blockly.Connection, b: Blockly.Connection): boolean;
}
}
declare module Blockly {
class ConnectionDB extends ConnectionDB__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class ConnectionDB__Class {
/**
* Database of connections.
* Connections are stored in order of their vertical component. This way
* connections in an area may be looked up quickly using a binary search.
* @param {!Blockly.IConnectionChecker} checker The workspace's
* connection type checker, used to decide if connections are valid during a
* drag.
* @constructor
*/
constructor(checker: Blockly.IConnectionChecker);
/**
* Add a connection to the database. Should not already exist in the database.
* @param {!Blockly.RenderedConnection} connection The connection to be added.
* @param {number} yPos The y position used to decide where to insert the
* connection.
* @package
*/
addConnection(connection: Blockly.RenderedConnection, yPos: number): void;
/**
* Remove a connection from the database. Must already exist in DB.
* @param {!Blockly.RenderedConnection} connection The connection to be removed.
* @param {number} yPos The y position used to find the index of the connection.
* @throws {Error} If the connection cannot be found in the database.
*/
removeConnection(connection: Blockly.RenderedConnection, yPos: number): void;
/**
* Find all nearby connections to the given connection.
* Type checking does not apply, since this function is used for bumping.
* @param {!Blockly.RenderedConnection} connection The connection whose
* neighbours should be returned.
* @param {number} maxRadius The maximum radius to another connection.
* @return {!Array<!Blockly.RenderedConnection>} List of connections.
*/
getNeighbours(connection: Blockly.RenderedConnection, maxRadius: number): Blockly.RenderedConnection[];
/**
* Find the closest compatible connection to this connection.
* @param {!Blockly.RenderedConnection} conn The connection searching for a compatible
* mate.
* @param {number} maxRadius The maximum radius to another connection.
* @param {!Blockly.utils.Coordinate} dxy Offset between this connection's
* location in the database and the current location (as a result of
* dragging).
* @return {!{connection: Blockly.RenderedConnection, radius: number}}
* Contains two properties: 'connection' which is either another
* connection or null, and 'radius' which is the distance.
*/
searchForClosest(conn: Blockly.RenderedConnection, maxRadius: number, dxy: Blockly.utils.Coordinate): { connection: Blockly.RenderedConnection; radius: number };
}
}
declare module Blockly.ConnectionDB {
/**
* Initialize a set of connection DBs for a workspace.
* @param {!Blockly.IConnectionChecker} checker The workspace's
* connection checker, used to decide if connections are valid during a drag.
* @return {!Array<!Blockly.ConnectionDB>} Array of databases.
*/
function init(checker: Blockly.IConnectionChecker): Blockly.ConnectionDB[];
}
declare module Blockly {
/**
* Enum for the type of a connection or input.
* @enum {number}
*/
enum connectionTypes { INPUT_VALUE, OUTPUT_VALUE, NEXT_STATEMENT, PREVIOUS_STATEMENT }
}
declare module Blockly {
/**
* The multiplier for scroll wheel deltas using the line delta mode.
* @type {number}
*/
var LINE_MODE_MULTIPLIER: number;
/**
* The multiplier for scroll wheel deltas using the page delta mode.
* @type {number}
*/
var PAGE_MODE_MULTIPLIER: number;
/**
* Number of pixels the mouse must move before a drag starts.
*/
var DRAG_RADIUS: any /*missing*/;
/**
* Number of pixels the mouse must move before a drag/scroll starts from the
* flyout. Because the drag-intention is determined when this is reached, it is
* larger than Blockly.DRAG_RADIUS so that the drag-direction is clearer.
*/
var FLYOUT_DRAG_RADIUS: any /*missing*/;
/**
* Maximum misalignment between connections for them to snap together.
*/
var SNAP_RADIUS: any /*missing*/;
/**
* Maximum misalignment between connections for them to snap together,
* when a connection is already highlighted.
*/
var CONNECTING_SNAP_RADIUS: any /*missing*/;
/**
* How much to prefer staying connected to the current connection over moving to
* a new connection. The current previewed connection is considered to be this
* much closer to the matching connection on the block than it actually is.
*/
var CURRENT_CONNECTION_PREFERENCE: any /*missing*/;
/**
* Delay in ms between trigger and bumping unconnected block out of alignment.
*/
var BUMP_DELAY: any /*missing*/;
/**
* Maximum randomness in workspace units for bumping a block.
*/
var BUMP_RANDOMNESS: any /*missing*/;
/**
* Number of characters to truncate a collapsed block to.
*/
var COLLAPSE_CHARS: any /*missing*/;
/**
* Length in ms for a touch to become a long press.
*/
var LONGPRESS: any /*missing*/;
/**
* Prevent a sound from playing if another sound preceded it within this many
* milliseconds.
*/
var SOUND_LIMIT: any /*missing*/;
/**
* When dragging a block out of a stack, split the stack in two (true), or drag
* out the block healing the stack (false).
*/
var DRAG_STACK: any /*missing*/;
/**
* The richness of block colours, regardless of the hue.
* Must be in the range of 0 (inclusive) to 1 (exclusive).
*/
var HSV_SATURATION: any /*missing*/;
/**
* The intensity of block colours, regardless of the hue.
* Must be in the range of 0 (inclusive) to 1 (exclusive).
*/
var HSV_VALUE: any /*missing*/;
/**
* Sprited icons and images.
*/
var SPRITE: any /*missing*/;
/**
* ENUM for no drag operation.
* @const
*/
var DRAG_NONE: any /*missing*/;
/**
* ENUM for inside the sticky DRAG_RADIUS.
* @const
*/
var DRAG_STICKY: any /*missing*/;
/**
* ENUM for inside the non-sticky DRAG_RADIUS, for differentiating between
* clicks and drags.
* @const
*/
var DRAG_BEGIN: any /*missing*/;
/**
* ENUM for freely draggable (outside the DRAG_RADIUS, if one applies).
* @const
*/
var DRAG_FREE: any /*missing*/;
/**
* Lookup table for determining the opposite type of a connection.
* @const
*/
var OPPOSITE_TYPE: any /*missing*/;
/**
* String for use in the "custom" attribute of a category in toolbox XML.
* This string indicates that the category should be dynamically populated with
* variable blocks.
* @const {string}
*/
var VARIABLE_CATEGORY_NAME: any /*missing*/;
/**
* String for use in the "custom" attribute of a category in toolbox XML.
* This string indicates that the category should be dynamically populated with
* variable blocks.
* @const {string}
*/
var VARIABLE_DYNAMIC_CATEGORY_NAME: any /*missing*/;
/**
* String for use in the "custom" attribute of a category in toolbox XML.
* This string indicates that the category should be dynamically populated with
* procedure blocks.
* @const {string}
*/
var PROCEDURE_CATEGORY_NAME: any /*missing*/;
/**
* String for use in the dropdown created in field_variable.
* This string indicates that this option in the dropdown is 'Rename
* variable...' and if selected, should trigger the prompt to rename a variable.
* @const {string}
*/
var RENAME_VARIABLE_ID: any /*missing*/;
/**
* String for use in the dropdown created in field_variable.
* This string indicates that this option in the dropdown is 'Delete the "%1"
* variable' and if selected, should trigger the prompt to delete a variable.
* @const {string}
*/
var DELETE_VARIABLE_ID: any /*missing*/;
}
declare module Blockly.constants {
/**
* Enum for alignment of inputs.
* @enum {number}
*/
enum ALIGN { LEFT, CENTRE, RIGHT }
/**
* The language-neutral ID given to the collapsed input.
* @const {string}
*/
var COLLAPSED_INPUT_NAME: any /*missing*/;
/**
* The language-neutral ID given to the collapsed field.
* @const {string}
*/
var COLLAPSED_FIELD_NAME: any /*missing*/;
}
declare module Blockly.ContextMenu {
/**
* Which block is the context menu attached to?
* @type {Blockly.Block}
*/
var currentBlock: Blockly.Block;
/**
* Construct the menu based on the list of options and show the menu.
* @param {!Event} e Mouse event.
* @param {!Array<!Object>} options Array of menu options.
* @param {boolean} rtl True if RTL, false if LTR.
*/
function show(e: Event, options: Object[], rtl: boolean): void;
/**
* Hide the context menu.
*/
function hide(): void;
/**
* Dispose of the menu.
*/
function dispose(): void;
/**
* Create a callback function that creates and configures a block,
* then places the new block next to the original.
* @param {!Blockly.Block} block Original block.
* @param {!Element} xml XML representation of new block.
* @return {!Function} Function that creates a block.
*/
function callbackFactory(block: Blockly.Block, xml: Element): Function;
/**
* Make a context menu option for deleting the current workspace comment.
* @param {!Blockly.WorkspaceCommentSvg} comment The workspace comment where the
* right-click originated.
* @return {!Object} A menu option, containing text, enabled, and a callback.
* @package
*/
function commentDeleteOption(comment: Blockly.WorkspaceCommentSvg): Object;
/**
* Make a context menu option for duplicating the current workspace comment.
* @param {!Blockly.WorkspaceCommentSvg} comment The workspace comment where the
* right-click originated.
* @return {!Object} A menu option, containing text, enabled, and a callback.
* @package
*/
function commentDuplicateOption(comment: Blockly.WorkspaceCommentSvg): Object;
/**
* Make a context menu option for adding a comment on the workspace.
* @param {!Blockly.WorkspaceSvg} ws The workspace where the right-click
* originated.
* @param {!Event} e The right-click mouse event.
* @return {!Object} A menu option, containing text, enabled, and a callback.
* @package
* @suppress {strictModuleDepCheck,checkTypes} Suppress checks while workspace
* comments are not bundled in.
*/
function workspaceCommentOption(ws: Blockly.WorkspaceSvg, e: Event): Object;
}
declare module Blockly.ContextMenuItems {
/** Option to undo previous action. */
function registerUndo(): void;
/** Option to redo previous action. */
function registerRedo(): void;
/** Option to clean up blocks. */
function registerCleanup(): void;
/** Option to collapse all blocks. */
function registerCollapse(): void;
/** Option to expand all blocks. */
function registerExpand(): void;
/** Option to delete all blocks. */
function registerDeleteAll(): void;
/** Option to duplicate a block. */
function registerDuplicate(): void;
/** Option to add or remove block-level comment. */
function registerComment(): void;
/** Option to inline variables. */
function registerInline(): void;
/** Option to collapse or expand a block. */
function registerCollapseExpandBlock(): void;
/** Option to disable or enable a block. */
function registerDisable(): void;
/** Option to delete a block. */
function registerDelete(): void;
/** Option to open help for a block. */
function registerHelp(): void;
/**
* Registers all default context menu items. This should be called once per instance of
* ContextMenuRegistry.
* @package
*/
function registerDefaultOptions(): void;
}
declare module Blockly {
class ContextMenuRegistry extends ContextMenuRegistry__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class ContextMenuRegistry__Class {
/**
* Class for the registry of context menu items. This is intended to be a
* singleton. You should not create a new instance, and only access this class
* from Blockly.ContextMenuRegistry.registry.
* @constructor
*/
constructor();
/**
* Registers a RegistryItem.
* @param {!Blockly.ContextMenuRegistry.RegistryItem} item Context menu item to register.
* @throws {Error} if an item with the given ID already exists.
*/
register(item: Blockly.ContextMenuRegistry.RegistryItem): void;
/**
* Unregisters a RegistryItem with the given ID.
* @param {string} id The ID of the RegistryItem to remove.
* @throws {Error} if an item with the given ID does not exist.
*/
unregister(id: string): void;
/**
* @param {string} id The ID of the RegistryItem to get.
* @return {?Blockly.ContextMenuRegistry.RegistryItem} RegistryItem or null if not found
*/
getItem(id: string): Blockly.ContextMenuRegistry.RegistryItem;
/**
* Gets the valid context menu options for the given scope type (e.g. block or workspace) and scope.
* Blocks are only shown if the preconditionFn shows they should not be hidden.
* @param {!Blockly.ContextMenuRegistry.ScopeType} scopeType Type of scope where menu should be
* shown (e.g. on a block or on a workspace)
* @param {!Blockly.ContextMenuRegistry.Scope} scope Current scope of context menu
* (i.e., the exact workspace or block being clicked on)
* @return {!Array<!Blockly.ContextMenuRegistry.ContextMenuOption>} the list of ContextMenuOptions
*/
getContextMenuOptions(scopeType: Blockly.ContextMenuRegistry.ScopeType, scope: Blockly.ContextMenuRegistry.Scope): Blockly.ContextMenuRegistry.ContextMenuOption[];
}
}
declare module Blockly.ContextMenuRegistry {
/**
* Where this menu item should be rendered. If the menu item should be rendered in multiple
* scopes, e.g. on both a block and a workspace, it should be registered for each scope.
* @enum {string}
*/
enum ScopeType { BLOCK, WORKSPACE }
/**
* The actual workspace/block where the menu is being rendered. This is passed to callback and
* displayText functions that depend on this information.
* @typedef {{
* block: (Blockly.BlockSvg|undefined),
* workspace: (Blockly.WorkspaceSvg|undefined)
* }}
*/
interface Scope {
block: Blockly.BlockSvg|any /*undefined*/;
workspace: Blockly.WorkspaceSvg|any /*undefined*/
}
/**
* A menu item as entered in the registry.
* @typedef {{
* callback: function(!Blockly.ContextMenuRegistry.Scope),
* scopeType: !Blockly.ContextMenuRegistry.ScopeType,
* displayText: ((function(!Blockly.ContextMenuRegistry.Scope):string)|string),
* preconditionFn: function(!Blockly.ContextMenuRegistry.Scope):string,
* weight: number,
* id: string
* }}
*/
interface RegistryItem {
callback: { (_0: Blockly.ContextMenuRegistry.Scope): any /*missing*/ };
scopeType: Blockly.ContextMenuRegistry.ScopeType;
displayText: { (_0: Blockly.ContextMenuRegistry.Scope): string }|string;
preconditionFn: { (_0: Blockly.ContextMenuRegistry.Scope): string };
weight: number;
id: string
}
/**
* A menu item as presented to contextmenu.js.
* @typedef {{
* text: string,
* enabled: boolean,
* callback: function(!Blockly.ContextMenuRegistry.Scope),
* scope: !Blockly.ContextMenuRegistry.Scope,
* weight: number
* }}
*/
interface ContextMenuOption {
text: string;
enabled: boolean;
callback: { (_0: Blockly.ContextMenuRegistry.Scope): any /*missing*/ };
scope: Blockly.ContextMenuRegistry.Scope;
weight: number
}
/**
* Singleton instance of this class. All interactions with this class should be
* done on this object.
* @type {?Blockly.ContextMenuRegistry}
*/
var registry: Blockly.ContextMenuRegistry;
}
declare module Blockly.Css {
/**
* Add some CSS to the blob that will be injected later. Allows optional
* components such as fields and the toolbox to store separate CSS.
* The provided array of CSS will be destroyed by this function.
* @param {!Array<string>} cssArray Array of CSS strings.
*/
function register(cssArray: string[]): void;
/**
* Inject the CSS into the DOM. This is preferable over using a regular CSS
* file since:
* a) It loads synchronously and doesn't force a redraw later.
* b) It speeds up loading by not blocking on a separate HTTP transfer.
* c) The CSS content may be made dynamic depending on init options.
* @param {boolean} hasCss If false, don't inject CSS
* (providing CSS becomes the document's responsibility).
* @param {string} pathToMedia Path from page to the Blockly media directory.
*/
function inject(hasCss: boolean, pathToMedia: string): void;
/**
* Array making up the CSS content for Blockly.
*/
var CONTENT: any /*missing*/;
}
declare module Blockly {
class DeleteArea extends DeleteArea__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class DeleteArea__Class extends Blockly.DragTarget__Class implements Blockly.IDeleteArea {
/**
* Abstract class for a component that can delete a block or bubble that is
* dropped on top of it.
* @extends {Blockly.DragTarget}
* @implements {Blockly.IDeleteArea}
* @constructor
*/
constructor();
/**
* Whether the last block or bubble dragged over this delete area would be
* deleted if dropped on this component.
* This property is not updated after the block or bubble is deleted.
* @type {boolean}
* @protected
*/
wouldDelete_: boolean;
/**
* Returns whether the provided block or bubble would be deleted if dropped on
* this area.
* This method should check if the element is deletable and is always called
* before onDragEnter/onDragOver/onDragExit.
* @param {!Blockly.IDraggable} element The block or bubble currently being
* dragged.
* @param {boolean} couldConnect Whether the element could could connect to
* another.
* @return {boolean} Whether the element provided would be deleted if dropped on
* this area.
*/
wouldDelete(element: Blockly.IDraggable, couldConnect: boolean): boolean;
/**
* Updates the internal wouldDelete_ state.
* @param {boolean} wouldDelete The new value for the wouldDelete state.
* @protected
*/
updateWouldDelete_(wouldDelete: boolean): void;
}
}
declare module Blockly {
class DragTarget extends DragTarget__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class DragTarget__Class implements Blockly.IDragTarget {
/**
* Abstract class for a component with custom behaviour when a block or bubble
* is dragged over or dropped on top of it.
* @implements {Blockly.IDragTarget}
* @constructor
*/
constructor();
/**
* Returns the bounding rectangle of the drag target area in pixel units
* relative to the Blockly injection div.
* @return {?Blockly.utils.Rect} The component's bounding box. Null if drag
* target area should be ignored.
*/
getClientRect(): Blockly.utils.Rect;
/**
* Handles when a cursor with a block or bubble enters this drag target.
* @param {!Blockly.IDraggable} _dragElement The block or bubble currently being
* dragged.
*/
onDragEnter(_dragElement: Blockly.IDraggable): void;
/**
* Handles when a cursor with a block or bubble is dragged over this drag
* target.
* @param {!Blockly.IDraggable} _dragElement The block or bubble currently being
* dragged.
*/
onDragOver(_dragElement: Blockly.IDraggable): void;
/**
* Handles when a cursor with a block or bubble exits this drag target.
* @param {!Blockly.IDraggable} _dragElement The block or bubble currently being
* dragged.
*/
onDragExit(_dragElement: Blockly.IDraggable): void;
/**
* Handles when a block or bubble is dropped on this component.
* Should not handle delete here.
* @param {!Blockly.IDraggable} _dragElement The block or bubble currently being
* dragged.
*/
onDrop(_dragElement: Blockly.IDraggable): void;
/**
* Returns whether the provided block or bubble should not be moved after being
* dropped on this component. If true, the element will return to where it was
* when the drag started.
* @param {!Blockly.IDraggable} _dragElement The block or bubble currently being
* dragged.
* @return {boolean} Whether the block or bubble provided should be returned to
* drag start.
*/
shouldPreventMove(_dragElement: Blockly.IDraggable): boolean;
}
}
declare module Blockly {
class DropDownDiv extends DropDownDiv__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class DropDownDiv__Class {
/**
* Class for drop-down div.
* @constructor
* @package
*/
constructor();
}
}
declare module Blockly.DropDownDiv {
/**
* Arrow size in px. Should match the value in CSS
* (need to position pre-render).
* @type {number}
* @const
*/
var ARROW_SIZE: number;
/**
* Drop-down border size in px. Should match the value in CSS (need to position
* the arrow).
* @type {number}
* @const
*/
var BORDER_SIZE: number;
/**
* Amount the arrow must be kept away from the edges of the main drop-down div,
* in px.
* @type {number}
* @const
*/
var ARROW_HORIZONTAL_PADDING: number;
/**
* Amount drop-downs should be padded away from the source, in px.
* @type {number}
* @const
*/
var PADDING_Y: number;
/**
* Length of animations in seconds.
* @type {number}
* @const
*/
var ANIMATION_TIME: number;
/**
* Dropdown bounds info object used to encapsulate sizing information about a
* bounding element (bounding box and width/height).
* @typedef {{
* top:number,
* left:number,
* bottom:number,
* right:number,
* width:number,
* height:number
* }}
*/
interface BoundsInfo {
top: number;
left: number;
bottom: number;
right: number;
width: number;
height: number
}
/**
* Dropdown position metrics.
* @typedef {{
* initialX:number,
* initialY:number,
* finalX:number,
* finalY:number,
* arrowX:?number,
* arrowY:?number,
* arrowAtTop:?boolean,
* arrowVisible:boolean
* }}
*/
interface PositionMetrics {
initialX: number;
initialY: number;
finalX: number;
finalY: number;
arrowX: number;
arrowY: number;
arrowAtTop: boolean;
arrowVisible: boolean
}
/**
* Create and insert the DOM element for this div.
* @package
*/
function createDom(): void;
/**
* Set an element to maintain bounds within. Drop-downs will appear
* within the box of this element if possible.
* @param {Element} boundsElement Element to bind drop-down to.
*/
function setBoundsElement(boundsElement: Element): void;
/**
* Provide the div for inserting content into the drop-down.
* @return {!Element} Div to populate with content.
*/
function getContentDiv(): Element;
/**
* Clear the content of the drop-down.
*/
function clearContent(): void;
/**
* Set the colour for the drop-down.
* @param {string} backgroundColour Any CSS colour for the background.
* @param {string} borderColour Any CSS colour for the border.
*/
function setColour(backgroundColour: string, borderColour: string): void;
/**
* Shortcut to show and place the drop-down with positioning determined
* by a particular block. The primary position will be below the block,
* and the secondary position above the block. Drop-down will be
* constrained to the block's workspace.
* @param {!Blockly.Field} field The field showing the drop-down.
* @param {!Blockly.BlockSvg} block Block to position the drop-down around.
* @param {Function=} opt_onHide Optional callback for when the drop-down is
* hidden.
* @param {number=} opt_secondaryYOffset Optional Y offset for above-block
* positioning.
* @return {boolean} True if the menu rendered below block; false if above.
*/
function showPositionedByBlock(field: Blockly.Field, block: Blockly.BlockSvg, opt_onHide?: Function, opt_secondaryYOffset?: number): boolean;
/**
* Shortcut to show and place the drop-down with positioning determined
* by a particular field. The primary position will be below the field,
* and the secondary position above the field. Drop-down will be
* constrained to the block's workspace.
* @param {!Blockly.Field} field The field to position the dropdown against.
* @param {Function=} opt_onHide Optional callback for when the drop-down is
* hidden.
* @param {number=} opt_secondaryYOffset Optional Y offset for above-block
* positioning.
* @return {boolean} True if the menu rendered below block; false if above.
*/
function showPositionedByField(field: Blockly.Field, opt_onHide?: Function, opt_secondaryYOffset?: number): boolean;
/**
* Show and place the drop-down.
* The drop-down is placed with an absolute "origin point" (x, y) - i.e.,
* the arrow will point at this origin and box will positioned below or above
* it. If we can maintain the container bounds at the primary point, the arrow
* will point there, and the container will be positioned below it.
* If we can't maintain the container bounds at the primary point, fall-back to
* the secondary point and position above.
* @param {Object} owner The object showing the drop-down
* @param {boolean} rtl Right-to-left (true) or left-to-right (false).
* @param {number} primaryX Desired origin point x, in absolute px.
* @param {number} primaryY Desired origin point y, in absolute px.
* @param {number} secondaryX Secondary/alternative origin point x, in absolute
* px.
* @param {number} secondaryY Secondary/alternative origin point y, in absolute
* px.
* @param {Function=} opt_onHide Optional callback for when the drop-down is
* hidden.
* @return {boolean} True if the menu rendered at the primary origin point.
* @package
*/
function show(owner: Object, rtl: boolean, primaryX: number, primaryY: number, secondaryX: number, secondaryY: number, opt_onHide?: Function): boolean;
/**
* Get the x positions for the left side of the DropDownDiv and the arrow,
* accounting for the bounds of the workspace.
* @param {number} sourceX Desired origin point x, in absolute px.
* @param {number} boundsLeft The left edge of the bounding element, in
* absolute px.
* @param {number} boundsRight The right edge of the bounding element, in
* absolute px.
* @param {number} divWidth The width of the div in px.
* @return {{divX: number, arrowX: number}} An object containing metrics for
* the x positions of the left side of the DropDownDiv and the arrow.
* @package
*/
function getPositionX(sourceX: number, boundsLeft: number, boundsRight: number, divWidth: number): { divX: number; arrowX: number };
/**
* Is the container visible?
* @return {boolean} True if visible.
*/
function isVisible(): boolean;
/**
* Hide the menu only if it is owned by the provided object.
* @param {Object} owner Object which must be owning the drop-down to hide.
* @param {boolean=} opt_withoutAnimation True if we should hide the dropdown
* without animating.
* @return {boolean} True if hidden.
*/
function hideIfOwner(owner: Object, opt_withoutAnimation?: boolean): boolean;
/**
* Hide the menu, triggering animation.
*/
function hide(): void;
/**
* Hide the menu, without animation.
*/
function hideWithoutAnimation(): void;
/**
* Repositions the dropdownDiv on window resize. If it doesn't know how to
* calculate the new position, it will just hide it instead.
* @package
*/
function repositionForWindowResize(): void;
}
declare module Blockly.Extensions {
/**
* Registers a new extension function. Extensions are functions that help
* initialize blocks, usually adding dynamic behavior such as onchange
* handlers and mutators. These are applied using Block.applyExtension(), or
* the JSON "extensions" array attribute.
* @param {string} name The name of this extension.
* @param {Function} initFn The function to initialize an extended block.
* @throws {Error} if the extension name is empty, the extension is already
* registered, or extensionFn is not a function.
*/
function register(name: string, initFn: Function): void;
/**
* Registers a new extension function that adds all key/value of mixinObj.
* @param {string} name The name of this extension.
* @param {!Object} mixinObj The values to mix in.
* @throws {Error} if the extension name is empty or the extension is already
* registered.
*/
function registerMixin(name: string, mixinObj: Object): void;
/**
* Registers a new extension function that adds a mutator to the block.
* At register time this performs some basic sanity checks on the mutator.
* The wrapper may also add a mutator dialog to the block, if both compose and
* decompose are defined on the mixin.
* @param {string} name The name of this mutator extension.
* @param {!Object} mixinObj The values to mix in.
* @param {(function())=} opt_helperFn An optional function to apply after
* mixing in the object.
* @param {!Array<string>=} opt_blockList A list of blocks to appear in the
* flyout of the mutator dialog.
* @throws {Error} if the mutation is invalid or can't be applied to the block.
*/
function registerMutator(name: string, mixinObj: Object, opt_helperFn?: { (): any /*missing*/ }, opt_blockList?: string[]): void;
/**
* Unregisters the extension registered with the given name.
* @param {string} name The name of the extension to unregister.
*/
function unregister(name: string): void;
/**
* Applies an extension method to a block. This should only be called during
* block construction.
* @param {string} name The name of the extension.
* @param {!Blockly.Block} block The block to apply the named extension to.
* @param {boolean} isMutator True if this extension defines a mutator.
* @throws {Error} if the extension is not found.
*/
function apply(name: string, block: Blockly.Block, isMutator: boolean): void;
/**
* Builds an extension function that will map a dropdown value to a tooltip
* string.
*
* This method includes multiple checks to ensure tooltips, dropdown options,
* and message references are aligned. This aims to catch errors as early as
* possible, without requiring developers to manually test tooltips under each
* option. After the page is loaded, each tooltip text string will be checked
* for matching message keys in the internationalized string table. Deferring
* this until the page is loaded decouples loading dependencies. Later, upon
* loading the first block of any given type, the extension will validate every
* dropdown option has a matching tooltip in the lookupTable. Errors are
* reported as warnings in the console, and are never fatal.
* @param {string} dropdownName The name of the field whose value is the key
* to the lookup table.
* @param {!Object<string, string>} lookupTable The table of field values to
* tooltip text.
* @return {!Function} The extension function.
*/
function buildTooltipForDropdown(dropdownName: string, lookupTable: { [key: string]: string }): Function;
/**
* Builds an extension function that will install a dynamic tooltip. The
* tooltip message should include the string '%1' and that string will be
* replaced with the text of the named field.
* @param {string} msgTemplate The template form to of the message text, with
* %1 placeholder.
* @param {string} fieldName The field with the replacement text.
* @return {!Function} The extension function.
*/
function buildTooltipWithFieldText(msgTemplate: string, fieldName: string): Function;
}
declare module Blockly {
class Field extends Field__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Field__Class implements Blockly.IASTNodeLocationSvg, Blockly.IASTNodeLocationWithBlock, Blockly.IKeyboardAccessible, Blockly.IRegistrable {
/**
* Abstract class for an editable field.
* @param {*} value The initial value of the field.
* @param {?Function=} opt_validator A function that is called to validate
* changes to the field's value. Takes in a value & returns a validated
* value, or null to abort the change.
* @param {Object=} opt_config A map of options used to configure the field. See
* the individual field's documentation for a list of properties this
* parameter supports.
* @constructor
* @implements {Blockly.IASTNodeLocationSvg}
* @implements {Blockly.IASTNodeLocationWithBlock}
* @implements {Blockly.IKeyboardAccessible}
* @implements {Blockly.IRegistrable}
*/
constructor(value: any, opt_validator?: Function, opt_config?: Object);
/**
* A generic value possessed by the field.
* Should generally be non-null, only null when the field is created.
* @type {*}
* @protected
*/
value_: any;
/**
* Validation function called when user edits an editable field.
* @type {Function}
* @protected
*/
validator_: Function;
/**
* The size of the area rendered by the field.
* @type {!Blockly.utils.Size}
* @protected
*/
size_: Blockly.utils.Size;
/**
* The rendered field's SVG group element.
* @type {SVGGElement}
* @protected
*/
fieldGroup_: SVGGElement;
/**
* The rendered field's SVG border element.
* @type {SVGRectElement}
* @protected
*/
borderRect_: SVGRectElement;
/**
* The rendered field's SVG text element.
* @type {SVGTextElement}
* @protected
*/
textElement_: SVGTextElement;
/**
* The rendered field's text content element.
* @type {Text}
* @protected
*/
textContent_: Text;
/**
* Constants associated with the source block's renderer.
* @type {Blockly.blockRendering.ConstantProvider}
* @protected
*/
constants_: Blockly.blockRendering.ConstantProvider;
/**
* The default value for this field.
* @type {*}
* @protected
*/
DEFAULT_VALUE: any;
/**
* Name of field. Unique within each block.
* Static labels are usually unnamed.
* @type {string|undefined}
*/
name: string|any /*undefined*/;
/**
* Has this field been disposed of?
* @type {boolean}
* @package
*/
disposed: boolean;
/**
* Maximum characters of text to display before adding an ellipsis.
* @type {number}
*/
maxDisplayLength: number;
/**
* Block this field is attached to. Starts as null, then set in init.
* @type {Blockly.Block}
* @protected
*/
sourceBlock_: Blockly.Block;
/**
* Does this block need to be re-rendered?
* @type {boolean}
* @protected
*/
isDirty_: boolean;
/**
* Is the field visible, or hidden due to the block being collapsed?
* @type {boolean}
* @protected
*/
visible_: boolean;
/**
* The element the click handler is bound to.
* @type {Element}
* @protected
*/
clickTarget_: Element;
/**
* A developer hook to override the returned text of this field.
* Override if the text representation of the value of this field
* is not just a string cast of its value.
* Return null to resort to a string cast.
* @return {?string} Current text. Return null to resort to a string cast.
* @protected
*/
getText_(): string;
/**
* An optional method that can be defined to show an editor when the field is
* clicked. Blockly will automatically set the field as clickable if this
* method is defined.
* @param {Event=} opt_e Optional mouse event that triggered the field to open,
* or undefined if triggered programmatically.
* @return {void}
* @protected
*/
showEditor_(opt_e?: Event): void;
/**
* Editable fields usually show some sort of UI indicating they are editable.
* They will also be saved by the XML renderer.
* @type {boolean}
*/
EDITABLE: boolean;
/**
* Serializable fields are saved by the XML renderer, non-serializable fields
* are not. Editable fields should also be serializable. This is not the
* case by default so that SERIALIZABLE is backwards compatible.
* @type {boolean}
*/
SERIALIZABLE: boolean;
/**
* Process the configuration map passed to the field.
* @param {!Object} config A map of options used to configure the field. See
* the individual field's documentation for a list of properties this
* parameter supports.
* @protected
*/
configure_(config: Object): void;
/**
* Attach this field to a block.
* @param {!Blockly.Block} block The block containing this field.
*/
setSourceBlock(block: Blockly.Block): void;
/**
* Get the renderer constant provider.
* @return {?Blockly.blockRendering.ConstantProvider} The renderer constant
* provider.
*/
getConstants(): Blockly.blockRendering.ConstantProvider;
/**
* Get the block this field is attached to.
* @return {Blockly.Block} The block containing this field.
*/
getSourceBlock(): Blockly.Block;
/**
* Initialize everything to render this field. Override
* methods initModel and initView rather than this method.
* @package
*/
init(): void;
/**
* Create the block UI for this field.
* @package
*/
initView(): void;
/**
* Initializes the model of the field after it has been installed on a block.
* No-op by default.
* @package
*/
initModel(): void;
/**
* Create a field border rect element. Not to be overridden by subclasses.
* Instead modify the result of the function inside initView, or create a
* separate function to call.
* @protected
*/
createBorderRect_(): void;
/**
* Create a field text element. Not to be overridden by subclasses. Instead
* modify the result of the function inside initView, or create a separate
* function to call.
* @protected
*/
createTextElement_(): void;
/**
* Bind events to the field. Can be overridden by subclasses if they need to do
* custom input handling.
* @protected
*/
bindEvents_(): void;
/**
* Sets the field's value based on the given XML element. Should only be
* called by Blockly.Xml.
* @param {!Element} fieldElement The element containing info about the
* field's state.
* @package
*/
fromXml(fieldElement: Element): void;
/**
* Serializes this field's value to XML. Should only be called by Blockly.Xml.
* @param {!Element} fieldElement The element to populate with info about the
* field's state.
* @return {!Element} The element containing info about the field's state.
* @package
*/
toXml(fieldElement: Element): Element;
/**
* Dispose of all DOM objects and events belonging to this editable field.
* @package
*/
dispose(): void;
/**
* Add or remove the UI indicating if this field is editable or not.
*/
updateEditable(): void;
/**
* Check whether this field defines the showEditor_ function.
* @return {boolean} Whether this field is clickable.
*/
isClickable(): boolean;
/**
* Check whether this field is currently editable. Some fields are never
* EDITABLE (e.g. text labels). Other fields may be EDITABLE but may exist on
* non-editable blocks.
* @return {boolean} Whether this field is editable and on an editable block
*/
isCurrentlyEditable(): boolean;
/**
* Check whether this field should be serialized by the XML renderer.
* Handles the logic for backwards compatibility and incongruous states.
* @return {boolean} Whether this field should be serialized or not.
*/
isSerializable(): boolean;
/**
* Gets whether this editable field is visible or not.
* @return {boolean} True if visible.
*/
isVisible(): boolean;
/**
* Sets whether this editable field is visible or not. Should only be called
* by input.setVisible.
* @param {boolean} visible True if visible.
* @package
*/
setVisible(visible: boolean): void;
/**
* Sets a new validation function for editable fields, or clears a previously
* set validator.
*
* The validator function takes in the new field value, and returns
* validated value. The validated value could be the input value, a modified
* version of the input value, or null to abort the change.
*
* If the function does not return anything (or returns undefined) the new
* value is accepted as valid. This is to allow for fields using the
* validated function as a field-level change event notification.
*
* @param {Function} handler The validator function
* or null to clear a previous validator.
*/
setValidator(handler: Function): void;
/**
* Gets the validation function for editable fields, or null if not set.
* @return {?Function} Validation function, or null.
*/
getValidator(): Function;
/**
* Gets the group element for this editable field.
* Used for measuring the size and for positioning.
* @return {!SVGGElement} The group element.
*/
getSvgRoot(): SVGGElement;
/**
* Updates the field to match the colour/style of the block. Should only be
* called by BlockSvg.applyColour().
* @package
*/
applyColour(): void;
/**
* Used by getSize() to move/resize any DOM elements, and get the new size.
*
* All rendering that has an effect on the size/shape of the block should be
* done here, and should be triggered by getSize().
* @protected
*/
render_(): void;
/**
* Show an editor when the field is clicked only if the field is clickable.
* @param {Event=} opt_e Optional mouse event that triggered the field to open,
* or undefined if triggered programmatically.
* @package
*/
showEditor(opt_e?: Event): void;
/**
* Updates the size of the field based on the text.
* @param {number=} opt_margin margin to use when positioning the text element.
* @protected
*/
updateSize_(opt_margin?: number): void;
/**
* Position a field's text element after a size change. This handles both LTR
* and RTL positioning.
* @param {number} xOffset x offset to use when positioning the text element.
* @param {number} contentWidth The content width.
* @protected
*/
positionTextElement_(xOffset: number, contentWidth: number): void;
/**
* Position a field's border rect after a size change.
* @protected
*/
positionBorderRect_(): void;
/**
* Returns the height and width of the field.
*
* This should *in general* be the only place render_ gets called from.
* @return {!Blockly.utils.Size} Height and width.
*/
getSize(): Blockly.utils.Size;
/**
* Returns the bounding box of the rendered field, accounting for workspace
* scaling.
* @return {!Blockly.utils.Rect} An object with top, bottom, left, and right in
* pixels relative to the top left corner of the page (window coordinates).
* @package
*/
getScaledBBox(): Blockly.utils.Rect;
/**
* Get the text from this field to display on the block. May differ from
* ``getText`` due to ellipsis, and other formatting.
* @return {string} Text to display.
* @protected
*/
getDisplayText_(): string;
/**
* Get the text from this field.
* @return {string} Current text.
*/
getText(): string;
/**
* Force a rerender of the block that this field is installed on, which will
* rerender this field and adjust for any sizing changes.
* Other fields on the same block will not rerender, because their sizes have
* already been recorded.
* @package
*/
markDirty(): void;
/**
* Force a rerender of the block that this field is installed on, which will
* rerender this field and adjust for any sizing changes.
* Other fields on the same block will not rerender, because their sizes have
* already been recorded.
* @package
*/
forceRerender(): void;
/**
* Used to change the value of the field. Handles validation and events.
* Subclasses should override doClassValidation_ and doValueUpdate_ rather
* than this method.
* @param {*} newValue New value.
*/
setValue(newValue: any): void;
/**
* Get the current value of the field.
* @return {*} Current value.
*/
getValue(): any;
/**
* Used to validate a value. Returns input by default. Can be overridden by
* subclasses, see FieldDropdown.
* @param {*=} opt_newValue The value to be validated.
* @return {*} The validated value, same as input by default.
* @protected
*/
doClassValidation_(opt_newValue?: any): any;
/**
* Used to update the value of a field. Can be overridden by subclasses to do
* custom storage of values/updating of external things.
* @param {*} newValue The value to be saved.
* @protected
*/
doValueUpdate_(newValue: any): void;
/**
* Used to notify the field an invalid value was input. Can be overridden by
* subclasses, see FieldTextInput.
* No-op by default.
* @param {*} _invalidValue The input value that was determined to be invalid.
* @protected
*/
doValueInvalid_(_invalidValue: any): void;
/**
* Handle a mouse down event on a field.
* @param {!Event} e Mouse down event.
* @protected
*/
onMouseDown_(e: Event): void;
/**
* Sets the tooltip for this field.
* @param {?Blockly.Tooltip.TipInfo} newTip The
* text for the tooltip, a function that returns the text for the tooltip, a
* parent object whose tooltip will be used, or null to display the tooltip
* of the parent block. To not display a tooltip pass the empty string.
*/
setTooltip(newTip: Blockly.Tooltip.TipInfo): void;
/**
* Returns the tooltip text for this field.
* @return {string} The tooltip text for this field.
*/
getTooltip(): string;
/**
* The element to bind the click handler to. If not set explicitly, defaults
* to the SVG root of the field. When this element is
* clicked on an editable field, the editor will open.
* @return {!Element} Element to bind click handler to.
* @protected
*/
getClickTarget_(): Element;
/**
* Return the absolute coordinates of the top-left corner of this field.
* The origin (0,0) is the top-left corner of the page body.
* @return {!Blockly.utils.Coordinate} Object with .x and .y properties.
* @protected
*/
getAbsoluteXY_(): Blockly.utils.Coordinate;
/**
* Whether this field references any Blockly variables. If true it may need to
* be handled differently during serialization and deserialization. Subclasses
* may override this.
* @return {boolean} True if this field has any variable references.
* @package
*/
referencesVariables(): boolean;
/**
* Search through the list of inputs and their fields in order to find the
* parent input of a field.
* @return {Blockly.Input} The input that the field belongs to.
* @package
*/
getParentInput(): Blockly.Input;
/**
* Returns whether or not we should flip the field in RTL.
* @return {boolean} True if we should flip in RTL.
*/
getFlipRtl(): boolean;
/**
* Returns whether or not the field is tab navigable.
* @return {boolean} True if the field is tab navigable.
*/
isTabNavigable(): boolean;
/**
* Handles the given keyboard shortcut.
* @param {!Blockly.ShortcutRegistry.KeyboardShortcut} _shortcut The shortcut to be handled.
* @return {boolean} True if the shortcut has been handled, false otherwise.
* @public
*/
onShortcut(_shortcut: Blockly.ShortcutRegistry.KeyboardShortcut): boolean;
/**
* Add the cursor SVG to this fields SVG group.
* @param {SVGElement} cursorSvg The SVG root of the cursor to be added to the
* field group.
* @package
*/
setCursorSvg(cursorSvg: SVGElement): void;
/**
* Add the marker SVG to this fields SVG group.
* @param {SVGElement} markerSvg The SVG root of the marker to be added to the
* field group.
* @package
*/
setMarkerSvg(markerSvg: SVGElement): void;
/**
* Redraw any attached marker or cursor svgs if needed.
* @protected
*/
updateMarkers_(): void;
}
}
declare module Blockly.Field {
/**
* Non-breaking space.
* @const
*/
var NBSP: any /*missing*/;
}
declare module Blockly {
class FieldAngle extends FieldAngle__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class FieldAngle__Class extends Blockly.FieldTextInput__Class {
/**
* Class for an editable angle field.
* @param {string|number=} opt_value The initial value of the field. Should cast
* to a number. Defaults to 0.
* @param {Function=} opt_validator A function that is called to validate
* changes to the field's value. Takes in a number & returns a
* validated number, or null to abort the change.
* @param {Object=} opt_config A map of options used to configure the field.
* See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/angle#creation}
* for a list of properties this parameter supports.
* @extends {Blockly.FieldTextInput}
* @constructor
*/
constructor(opt_value?: string|number, opt_validator?: Function, opt_config?: Object);
/**
* The angle picker's gauge path depending on the value.
* @type {?SVGElement}
*/
gauge_: SVGElement;
/**
* The angle picker's line drawn representing the value's angle.
* @type {?SVGElement}
*/
line_: SVGElement;
/**
* The default value for this field.
* @type {*}
* @protected
*/
DEFAULT_VALUE: any;
/**
* Serializable fields are saved by the XML renderer, non-serializable fields
* are not. Editable fields should also be serializable.
* @type {boolean}
*/
SERIALIZABLE: boolean;
/**
* Create the block UI for this field.
* @package
*/
initView(): void;
/**
* Create and show the angle field's editor.
* @param {Event=} opt_e Optional mouse event that triggered the field to open,
* or undefined if triggered programmatically.
* @protected
*/
showEditor_(opt_e?: Event): void;
/**
* Set the angle to match the mouse's position.
* @param {!Event} e Mouse move event.
* @protected
*/
onMouseMove_(e: Event): void;
}
}
declare module Blockly.FieldAngle {
/**
* Construct a FieldAngle from a JSON arg object.
* @param {!Object} options A JSON object with options (angle).
* @return {!Blockly.FieldAngle} The new field instance.
* @package
* @nocollapse
*/
function fromJson(options: Object): Blockly.FieldAngle;
/**
* The default amount to round angles to when using a mouse or keyboard nav
* input. Must be a positive integer to support keyboard navigation.
* @const {number}
*/
var ROUND: any /*missing*/;
/**
* Half the width of protractor image.
* @const {number}
*/
var HALF: any /*missing*/;
/**
* Default property describing which direction makes an angle field's value
* increase. Angle increases clockwise (true) or counterclockwise (false).
* @const {boolean}
*/
var CLOCKWISE: any /*missing*/;
/**
* The default offset of 0 degrees (and all angles). Always offsets in the
* counterclockwise direction, regardless of the field's clockwise property.
* Usually either 0 (0 = right) or 90 (0 = up).
* @const {number}
*/
var OFFSET: any /*missing*/;
/**
* The default maximum angle to allow before wrapping.
* Usually either 360 (for 0 to 359.9) or 180 (for -179.9 to 180).
* @const {number}
*/
var WRAP: any /*missing*/;
/**
* Radius of protractor circle. Slightly smaller than protractor size since
* otherwise SVG crops off half the border at the edges.
* @const {number}
*/
var RADIUS: any /*missing*/;
}
declare module Blockly {
class FieldCheckbox extends FieldCheckbox__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class FieldCheckbox__Class extends Blockly.Field__Class {
/**
* Class for a checkbox field.
* @param {string|boolean=} opt_value The initial value of the field. Should
* either be 'TRUE', 'FALSE' or a boolean. Defaults to 'FALSE'.
* @param {Function=} opt_validator A function that is called to validate
* changes to the field's value. Takes in a value ('TRUE' or 'FALSE') &
* returns a validated value ('TRUE' or 'FALSE'), or null to abort the
* change.
* @param {Object=} opt_config A map of options used to configure the field.
* See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/checkbox#creation}
* for a list of properties this parameter supports.
* @extends {Blockly.Field}
* @constructor
*/
constructor(opt_value?: string|boolean, opt_validator?: Function, opt_config?: Object);
/**
* The default value for this field.
* @type {*}
* @protected
*/
DEFAULT_VALUE: any;
/**
* Serializable fields are saved by the XML renderer, non-serializable fields
* are not. Editable fields should also be serializable.
* @type {boolean}
*/
SERIALIZABLE: boolean;
/**
* Mouse cursor style when over the hotspot that initiates editability.
*/
CURSOR: any /*missing*/;
/**
* Create the block UI for this checkbox.
* @package
*/
initView(): void;
/**
* Set the character used for the check mark.
* @param {?string} character The character to use for the check mark, or
* null to use the default.
*/
setCheckCharacter(character: string): void;
/**
* Toggle the state of the checkbox on click.
* @protected
*/
showEditor_(): void;
/**
* Ensure that the input value is valid ('TRUE' or 'FALSE').
* @param {*=} opt_newValue The input value.
* @return {?string} A valid value ('TRUE' or 'FALSE), or null if invalid.
* @protected
*/
doClassValidation_(opt_newValue?: any): string;
/**
* Update the value of the field, and update the checkElement.
* @param {*} newValue The value to be saved. The default validator guarantees
* that this is a either 'TRUE' or 'FALSE'.
* @protected
*/
doValueUpdate_(newValue: any): void;
/**
* Get the value of this field, either 'TRUE' or 'FALSE'.
* @return {string} The value of this field.
*/
getValue(): string;
/**
* Get the boolean value of this field.
* @return {boolean} The boolean value of this field.
*/
getValueBoolean(): boolean;
/**
* Get the text of this field. Used when the block is collapsed.
* @return {string} Text representing the value of this field
* ('true' or 'false').
*/
getText(): string;
}
}
declare module Blockly.FieldCheckbox {
/**
* Construct a FieldCheckbox from a JSON arg object.
* @param {!Object} options A JSON object with options (checked).
* @return {!Blockly.FieldCheckbox} The new field instance.
* @package
* @nocollapse
*/
function fromJson(options: Object): Blockly.FieldCheckbox;
/**
* Default character for the checkmark.
* @type {string}
* @const
*/
var CHECK_CHAR: string;
}
declare module Blockly {
class FieldColour extends FieldColour__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class FieldColour__Class extends Blockly.Field__Class {
/**
* Class for a colour input field.
* @param {string=} opt_value The initial value of the field. Should be in
* '#rrggbb' format. Defaults to the first value in the default colour array.
* @param {Function=} opt_validator A function that is called to validate
* changes to the field's value. Takes in a colour string & returns a
* validated colour string ('#rrggbb' format), or null to abort the change.
* @param {Object=} opt_config A map of options used to configure the field.
* See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/colour}
* for a list of properties this parameter supports.
* @extends {Blockly.Field}
* @constructor
*/
constructor(opt_value?: string, opt_validator?: Function, opt_config?: Object);
/**
* Serializable fields are saved by the XML renderer, non-serializable fields
* are not. Editable fields should also be serializable.
* @type {boolean}
*/
SERIALIZABLE: boolean;
/**
* Mouse cursor style when over the hotspot that initiates the editor.
*/
CURSOR: any /*missing*/;
/**
* Used to tell if the field needs to be rendered the next time the block is
* rendered. Colour fields are statically sized, and only need to be
* rendered at initialization.
* @type {boolean}
* @protected
*/
isDirty_: boolean;
/**
* Create the block UI for this colour field.
* @package
*/
initView(): void;
/**
* Ensure that the input value is a valid colour.
* @param {*=} opt_newValue The input value.
* @return {?string} A valid colour, or null if invalid.
* @protected
*/
doClassValidation_(opt_newValue?: any): string;
/**
* Update the value of this colour field, and update the displayed colour.
* @param {*} newValue The value to be saved. The default validator guarantees
* that this is a colour in '#rrggbb' format.
* @protected
*/
doValueUpdate_(newValue: any): void;
/**
* Get the text for this field. Used when the block is collapsed.
* @return {string} Text representing the value of this field.
*/
getText(): string;
/**
* The default value for this field.
* @type {*}
* @protected
*/
DEFAULT_VALUE: any;
/**
* Set a custom colour grid for this field.
* @param {Array<string>} colours Array of colours for this block,
* or null to use default (Blockly.FieldColour.COLOURS).
* @param {Array<string>=} opt_titles Optional array of colour tooltips,
* or null to use default (Blockly.FieldColour.TITLES).
* @return {!Blockly.FieldColour} Returns itself (for method chaining).
*/
setColours(colours: string[], opt_titles?: string[]): Blockly.FieldColour;
/**
* Set a custom grid size for this field.
* @param {number} columns Number of columns for this block,
* or 0 to use default (Blockly.FieldColour.COLUMNS).
* @return {!Blockly.FieldColour} Returns itself (for method chaining).
*/
setColumns(columns: number): Blockly.FieldColour;
/**
* Create and show the colour field's editor.
* @protected
*/
showEditor_(): void;
}
}
declare module Blockly.FieldColour {
/**
* Construct a FieldColour from a JSON arg object.
* @param {!Object} options A JSON object with options (colour).
* @return {!Blockly.FieldColour} The new field instance.
* @package
* @nocollapse
*/
function fromJson(options: Object): Blockly.FieldColour;
/**
* An array of colour strings for the palette.
* Copied from goog.ui.ColorPicker.SIMPLE_GRID_COLORS
* All colour pickers use this unless overridden with setColours.
* @type {!Array<string>}
*/
var COLOURS: string[];
/**
* An array of tooltip strings for the palette. If not the same length as
* COLOURS, the colour's hex code will be used for any missing titles.
* All colour pickers use this unless overridden with setColours.
* @type {!Array<string>}
*/
var TITLES: string[];
/**
* Number of columns in the palette.
* All colour pickers use this unless overridden with setColumns.
*/
var COLUMNS: any /*missing*/;
}
declare module Blockly {
class FieldDropdown extends FieldDropdown__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class FieldDropdown__Class extends Blockly.Field__Class {
/**
* Class for an editable dropdown field.
* @param {(!Array<!Array>|!Function)} menuGenerator A non-empty array of
* options for a dropdown list, or a function which generates these options.
* @param {Function=} opt_validator A function that is called to validate
* changes to the field's value. Takes in a language-neutral dropdown
* option & returns a validated language-neutral dropdown option, or null to
* abort the change.
* @param {Object=} opt_config A map of options used to configure the field.
* See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/dropdown#creation}
* for a list of properties this parameter supports.
* @extends {Blockly.Field}
* @constructor
* @throws {TypeError} If `menuGenerator` options are incorrectly structured.
*/
constructor(menuGenerator: any[][]|Function, opt_validator?: Function, opt_config?: Object);
/**
* An array of options for a dropdown list,
* or a function which generates these options.
* @type {(!Array<!Array>|
* !function(this:Blockly.FieldDropdown): !Array<!Array>)}
* @protected
*/
menuGenerator_: any[][]|{ (): any[][] };
/**
* The prefix field label, of common words set after options are trimmed.
* @type {?string}
* @package
*/
prefixField: string;
/**
* The suffix field label, of common words set after options are trimmed.
* @type {?string}
* @package
*/
suffixField: string;
/**
* The dropdown menu.
* @type {?Blockly.Menu}
* @protected
*/
menu_: Blockly.Menu;
/**
* Sets the field's value based on the given XML element. Should only be
* called by Blockly.Xml.
* @param {!Element} fieldElement The element containing info about the
* field's state.
* @package
*/
fromXml(fieldElement: Element): void;
/**
* Serializable fields are saved by the XML renderer, non-serializable fields
* are not. Editable fields should also be serializable.
* @type {boolean}
*/
SERIALIZABLE: boolean;
/**
* Mouse cursor style when over the hotspot that initiates the editor.
*/
CURSOR: any /*missing*/;
/**
* Create the block UI for this dropdown.
* @package
*/
initView(): void;
/**
* Whether or not the dropdown should add a border rect.
* @return {boolean} True if the dropdown field should add a border rect.
* @protected
*/
shouldAddBorderRect_(): boolean;
/**
* Create a tspan based arrow.
* @protected
*/
createTextArrow_(): void;
/**
* Create an SVG based arrow.
* @protected
*/
createSVGArrow_(): void;
/**
* Create a dropdown menu under the text.
* @param {Event=} opt_e Optional mouse event that triggered the field to open,
* or undefined if triggered programmatically.
* @protected
*/
showEditor_(opt_e?: Event): void;
/**
* Handle the selection of an item in the dropdown menu.
* @param {!Blockly.Menu} menu The Menu component clicked.
* @param {!Blockly.MenuItem} menuItem The MenuItem selected within menu.
* @protected
*/
onItemSelected_(menu: Blockly.Menu, menuItem: Blockly.MenuItem): void;
/**
* @return {boolean} True if the option list is generated by a function.
* Otherwise false.
*/
isOptionListDynamic(): boolean;
/**
* Return a list of the options for this dropdown.
* @param {boolean=} opt_useCache For dynamic options, whether or not to use the
* cached options or to re-generate them.
* @return {!Array<!Array>} A non-empty array of option tuples:
* (human-readable text or image, language-neutral name).
* @throws {TypeError} If generated options are incorrectly structured.
*/
getOptions(opt_useCache?: boolean): any[][];
/**
* Ensure that the input value is a valid language-neutral option.
* @param {*=} opt_newValue The input value.
* @return {?string} A valid language-neutral option, or null if invalid.
* @protected
*/
doClassValidation_(opt_newValue?: any): string;
/**
* Update the value of this dropdown field.
* @param {*} newValue The value to be saved. The default validator guarantees
* that this is one of the valid dropdown options.
* @protected
*/
doValueUpdate_(newValue: any): void;
/**
* Updates the dropdown arrow to match the colour/style of the block.
* @package
*/
applyColour(): void;
/**
* Draws the border with the correct width.
* @protected
*/
render_(): void;
}
}
declare module Blockly.FieldDropdown {
/**
* Dropdown image properties.
* @typedef {{
* src:string,
* alt:string,
* width:number,
* height:number
* }}
*/
interface ImageProperties {
src: string;
alt: string;
width: number;
height: number
}
/**
* Construct a FieldDropdown from a JSON arg object.
* @param {!Object} options A JSON object with options (options).
* @return {!Blockly.FieldDropdown} The new field instance.
* @package
* @nocollapse
*/
function fromJson(options: Object): Blockly.FieldDropdown;
/**
* Horizontal distance that a checkmark overhangs the dropdown.
*/
var CHECKMARK_OVERHANG: any /*missing*/;
/**
* Maximum height of the dropdown menu, as a percentage of the viewport height.
*/
var MAX_MENU_HEIGHT_VH: any /*missing*/;
/**
* Android can't (in 2014) display "▾", so use "▼" instead.
*/
var ARROW_CHAR: any /*missing*/;
/**
* Use the calculated prefix and suffix lengths to trim all of the options in
* the given array.
* @param {!Array<!Array>} options Array of option tuples:
* (human-readable text or image, language-neutral name).
* @param {number} prefixLength The length of the common prefix.
* @param {number} suffixLength The length of the common suffix
* @return {!Array<!Array>} A new array with all of the option text trimmed.
*/
function applyTrim_(options: any[][], prefixLength: number, suffixLength: number): any[][];
}
declare module Blockly {
class FieldImage extends FieldImage__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class FieldImage__Class extends Blockly.Field__Class {
/**
* Class for an image on a block.
* @param {string} src The URL of the image.
* @param {!(string|number)} width Width of the image.
* @param {!(string|number)} height Height of the image.
* @param {string=} opt_alt Optional alt text for when block is collapsed.
* @param {function(!Blockly.FieldImage)=} opt_onClick Optional function to be
* called when the image is clicked. If opt_onClick is defined, opt_alt must
* also be defined.
* @param {boolean=} opt_flipRtl Whether to flip the icon in RTL.
* @param {Object=} opt_config A map of options used to configure the field.
* See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/image#creation}
* for a list of properties this parameter supports.
* @extends {Blockly.Field}
* @constructor
*/
constructor(src: string, width: string|number, height: string|number, opt_alt?: string, opt_onClick?: { (_0: Blockly.FieldImage): any /*missing*/ }, opt_flipRtl?: boolean, opt_config?: Object);
/**
* The default value for this field.
* @type {*}
* @protected
*/
DEFAULT_VALUE: any;
/**
* Editable fields usually show some sort of UI indicating they are
* editable. This field should not.
* @type {boolean}
*/
EDITABLE: boolean;
/**
* Used to tell if the field needs to be rendered the next time the block is
* rendered. Image fields are statically sized, and only need to be
* rendered at initialization.
* @type {boolean}
* @protected
*/
isDirty_: boolean;
/**
* Create the block UI for this image.
* @package
*/
initView(): void;
/**
* Ensure that the input value (the source URL) is a string.
* @param {*=} opt_newValue The input value.
* @return {?string} A string, or null if invalid.
* @protected
*/
doClassValidation_(opt_newValue?: any): string;
/**
* Update the value of this image field, and update the displayed image.
* @param {*} newValue The value to be saved. The default validator guarantees
* that this is a string.
* @protected
*/
doValueUpdate_(newValue: any): void;
/**
* Set the alt text of this image.
* @param {?string} alt New alt text.
* @public
*/
setAlt(alt: string): void;
/**
* If field click is called, and click handler defined,
* call the handler.
* @protected
*/
showEditor_(): void;
/**
* Set the function that is called when this image is clicked.
* @param {?function(!Blockly.FieldImage)} func The function that is called
* when the image is clicked, or null to remove.
*/
setOnClickHandler(func: { (_0: Blockly.FieldImage): any /*missing*/ }): void;
}
}
declare module Blockly.FieldImage {
/**
* Construct a FieldImage from a JSON arg object,
* dereferencing any string table references.
* @param {!Object} options A JSON object with options (src, width, height,
* alt, and flipRtl).
* @return {!Blockly.FieldImage} The new field instance.
* @package
* @nocollapse
*/
function fromJson(options: Object): Blockly.FieldImage;
}
declare module Blockly {
class FieldLabel extends FieldLabel__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class FieldLabel__Class extends Blockly.Field__Class {
/**
* Class for a non-editable, non-serializable text field.
* @param {string=} opt_value The initial value of the field. Should cast to a
* string. Defaults to an empty string if null or undefined.
* @param {string=} opt_class Optional CSS class for the field's text.
* @param {Object=} opt_config A map of options used to configure the field.
* See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/label#creation}
* for a list of properties this parameter supports.
* @extends {Blockly.Field}
* @constructor
*/
constructor(opt_value?: string, opt_class?: string, opt_config?: Object);
/**
* The default value for this field.
* @type {*}
* @protected
*/
DEFAULT_VALUE: any;
/**
* Editable fields usually show some sort of UI indicating they are
* editable. This field should not.
* @type {boolean}
*/
EDITABLE: boolean;
/**
* Create block UI for this label.
* @package
*/
initView(): void;
/**
* Ensure that the input value casts to a valid string.
* @param {*=} opt_newValue The input value.
* @return {?string} A valid string, or null if invalid.
* @protected
*/
doClassValidation_(opt_newValue?: any): string;
/**
* Set the CSS class applied to the field's textElement_.
* @param {?string} cssClass The new CSS class name, or null to remove.
*/
setClass(cssClass: string): void;
}
}
declare module Blockly.FieldLabel {
/**
* Construct a FieldLabel from a JSON arg object,
* dereferencing any string table references.
* @param {!Object} options A JSON object with options (text, and class).
* @return {!Blockly.FieldLabel} The new field instance.
* @package
* @nocollapse
*/
function fromJson(options: Object): Blockly.FieldLabel;
}
declare module Blockly {
class FieldLabelSerializable extends FieldLabelSerializable__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class FieldLabelSerializable__Class extends Blockly.FieldLabel__Class {
/**
* Class for a non-editable, serializable text field.
* @param {*} opt_value The initial value of the field. Should cast to a
* string. Defaults to an empty string if null or undefined.
* @param {string=} opt_class Optional CSS class for the field's text.
* @param {Object=} opt_config A map of options used to configure the field.
* See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/label-serializable#creation}
* for a list of properties this parameter supports.
* @extends {Blockly.FieldLabel}
* @constructor
*
*/
constructor(opt_value: any, opt_class?: string, opt_config?: Object);
/**
* Editable fields usually show some sort of UI indicating they are
* editable. This field should not.
* @type {boolean}
*/
EDITABLE: boolean;
/**
* Serializable fields are saved by the XML renderer, non-serializable fields
* are not. This field should be serialized, but only edited programmatically.
* @type {boolean}
*/
SERIALIZABLE: boolean;
}
}
declare module Blockly.FieldLabelSerializable {
/**
* Construct a FieldLabelSerializable from a JSON arg object,
* dereferencing any string table references.
* @param {!Object} options A JSON object with options (text, and class).
* @return {!Blockly.FieldLabelSerializable} The new field instance.
* @package
* @nocollapse
*/
function fromJson(options: Object): Blockly.FieldLabelSerializable;
}
declare module Blockly {
class FieldMultilineInput extends FieldMultilineInput__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class FieldMultilineInput__Class extends Blockly.FieldTextInput__Class {
/**
* Class for an editable text area field.
* @param {string=} opt_value The initial content of the field. Should cast to a
* string. Defaults to an empty string if null or undefined.
* @param {Function=} opt_validator An optional function that is called
* to validate any constraints on what the user entered. Takes the new
* text as an argument and returns either the accepted text, a replacement
* text, or null to abort the change.
* @param {Object=} opt_config A map of options used to configure the field.
* See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/multiline-text-input#creation}
* for a list of properties this parameter supports.
* @extends {Blockly.FieldTextInput}
* @constructor
*/
constructor(opt_value?: string, opt_validator?: Function, opt_config?: Object);
/**
* The SVG group element that will contain a text element for each text row
* when initialized.
* @type {SVGGElement}
*/
textGroup_: SVGGElement;
/**
* Defines the maximum number of lines of field.
* If exceeded, scrolling functionality is enabled.
* @type {number}
* @protected
*/
maxLines_: number;
/**
* Whether Y overflow is currently occurring.
* @type {boolean}
* @protected
*/
isOverflowedY_: boolean;
/**
* Serializes this field's value to XML. Should only be called by Blockly.Xml.
* @param {!Element} fieldElement The element to populate with info about the
* field's state.
* @return {!Element} The element containing info about the field's state.
* @package
*/
toXml(fieldElement: Element): Element;
/**
* Sets the field's value based on the given XML element. Should only be
* called by Blockly.Xml.
* @param {!Element} fieldElement The element containing info about the
* field's state.
* @package
*/
fromXml(fieldElement: Element): void;
/**
* Create the block UI for this field.
* @package
*/
initView(): void;
/**
* Called by setValue if the text input is valid. Updates the value of the
* field, and updates the text of the field if it is not currently being
* edited (i.e. handled by the htmlInput_). Is being redefined here to update
* overflow state of the field.
* @param {*} newValue The value to be saved. The default validator guarantees
* that this is a string.
* @protected
*/
doValueUpdate_(newValue: any): void;
/**
* Updates the text of the textElement.
* @protected
*/
render_(): void;
/**
* Updates the size of the field based on the text.
* @protected
*/
updateSize_(): void;
/**
* Create the text input editor widget.
* @return {!HTMLTextAreaElement} The newly created text input editor.
* @protected
*/
widgetCreate_(): HTMLTextAreaElement;
/**
* Sets the maxLines config for this field.
* @param {number} maxLines Defines the maximum number of lines allowed,
* before scrolling functionality is enabled.
*/
setMaxLines(maxLines: number): void;
/**
* Returns the maxLines config of this field.
* @return {number} The maxLines config value.
*/
getMaxLines(): number;
/**
* Handle key down to the editor. Override the text input definition of this
* so as to not close the editor when enter is typed in.
* @param {!Event} e Keyboard event.
* @protected
*/
onHtmlInputKeyDown_(e: Event): void;
}
}
declare module Blockly.FieldMultilineInput {
/**
* Construct a FieldMultilineInput from a JSON arg object,
* dereferencing any string table references.
* @param {!Object} options A JSON object with options (text, and spellcheck).
* @return {!Blockly.FieldMultilineInput} The new field instance.
* @package
* @nocollapse
*/
function fromJson(options: Object): Blockly.FieldMultilineInput;
}
declare module Blockly {
class FieldNumber extends FieldNumber__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class FieldNumber__Class extends Blockly.FieldTextInput__Class {
/**
* Class for an editable number field.
* @param {string|number=} opt_value The initial value of the field. Should cast
* to a number. Defaults to 0.
* @param {?(string|number)=} opt_min Minimum value.
* @param {?(string|number)=} opt_max Maximum value.
* @param {?(string|number)=} opt_precision Precision for value.
* @param {?Function=} opt_validator A function that is called to validate
* changes to the field's value. Takes in a number & returns a validated
* number, or null to abort the change.
* @param {Object=} opt_config A map of options used to configure the field.
* See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/number#creation}
* for a list of properties this parameter supports.
* @extends {Blockly.FieldTextInput}
* @constructor
*/
constructor(opt_value?: string|number, opt_min?: string|number, opt_max?: string|number, opt_precision?: string|number, opt_validator?: Function, opt_config?: Object);
/**
* The minimum value this number field can contain.
* @type {number}
* @protected
*/
min_: number;
/**
* The maximum value this number field can contain.
* @type {number}
* @protected
*/
max_: number;
/**
* The multiple to which this fields value is rounded.
* @type {number}
* @protected
*/
precision_: number;
/**
* The default value for this field.
* @type {*}
* @protected
*/
DEFAULT_VALUE: any;
/**
* Serializable fields are saved by the XML renderer, non-serializable fields
* are not. Editable fields should also be serializable.
* @type {boolean}
*/
SERIALIZABLE: boolean;
/**
* Set the maximum, minimum and precision constraints on this field.
* Any of these properties may be undefined or NaN to be disabled.
* Setting precision (usually a power of 10) enforces a minimum step between
* values. That is, the user's value will rounded to the closest multiple of
* precision. The least significant digit place is inferred from the precision.
* Integers values can be enforces by choosing an integer precision.
* @param {?(number|string|undefined)} min Minimum value.
* @param {?(number|string|undefined)} max Maximum value.
* @param {?(number|string|undefined)} precision Precision for value.
*/
setConstraints(min: number|string|any /*undefined*/, max: number|string|any /*undefined*/, precision: number|string|any /*undefined*/): void;
/**
* Sets the minimum value this field can contain. Updates the value to reflect.
* @param {?(number|string|undefined)} min Minimum value.
*/
setMin(min: number|string|any /*undefined*/): void;
/**
* Returns the current minimum value this field can contain. Default is
* -Infinity.
* @return {number} The current minimum value this field can contain.
*/
getMin(): number;
/**
* Sets the maximum value this field can contain. Updates the value to reflect.
* @param {?(number|string|undefined)} max Maximum value.
*/
setMax(max: number|string|any /*undefined*/): void;
/**
* Returns the current maximum value this field can contain. Default is
* Infinity.
* @return {number} The current maximum value this field can contain.
*/
getMax(): number;
/**
* Sets the precision of this field's value, i.e. the number to which the
* value is rounded. Updates the field to reflect.
* @param {?(number|string|undefined)} precision The number to which the
* field's value is rounded.
*/
setPrecision(precision: number|string|any /*undefined*/): void;
/**
* Returns the current precision of this field. The precision being the
* number to which the field's value is rounded. A precision of 0 means that
* the value is not rounded.
* @return {number} The number to which this field's value is rounded.
*/
getPrecision(): number;
}
}
declare module Blockly.FieldNumber {
/**
* Construct a FieldNumber from a JSON arg object.
* @param {!Object} options A JSON object with options (value, min, max, and
* precision).
* @return {!Blockly.FieldNumber} The new field instance.
* @package
* @nocollapse
*/
function fromJson(options: Object): Blockly.FieldNumber;
}
declare module Blockly.fieldRegistry {
/**
* Registers a field type.
* Blockly.fieldRegistry.fromJson uses this registry to
* find the appropriate field type.
* @param {string} type The field type name as used in the JSON definition.
* @param {!Blockly.IRegistrableField} fieldClass The field class containing a
* fromJson function that can construct an instance of the field.
* @throws {Error} if the type name is empty, the field is already
* registered, or the fieldClass is not an object containing a fromJson
* function.
*/
function register(type: string, fieldClass: Blockly.IRegistrableField): void;
/**
* Unregisters the field registered with the given type.
* @param {string} type The field type name as used in the JSON definition.
*/
function unregister(type: string): void;
/**
* Construct a Field from a JSON arg object.
* Finds the appropriate registered field by the type name as registered using
* Blockly.fieldRegistry.register.
* @param {!Object} options A JSON object with a type and options specific
* to the field type.
* @return {?Blockly.Field} The new field instance or null if a field wasn't
* found with the given type name
* @package
*/
function fromJson(options: Object): Blockly.Field;
}
declare module Blockly {
class FieldTextInput extends FieldTextInput__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class FieldTextInput__Class extends Blockly.Field__Class {
/**
* Class for an editable text field.
* @param {string=} opt_value The initial value of the field. Should cast to a
* string. Defaults to an empty string if null or undefined.
* @param {?Function=} opt_validator A function that is called to validate
* changes to the field's value. Takes in a string & returns a validated
* string, or null to abort the change.
* @param {Object=} opt_config A map of options used to configure the field.
* See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/text-input#creation}
* for a list of properties this parameter supports.
* @extends {Blockly.Field}
* @constructor
*/
constructor(opt_value?: string, opt_validator?: Function, opt_config?: Object);
/**
* Allow browser to spellcheck this field.
* @type {boolean}
* @protected
*/
spellcheck_: boolean;
/**
* The HTML input element.
* @type {HTMLElement}
*/
htmlInput_: HTMLElement;
/**
* Whether the field should consider the whole parent block to be its click
* target.
* @type {?boolean}
*/
fullBlockClickTarget_: boolean;
/**
* The workspace that this field belongs to.
* @type {?Blockly.WorkspaceSvg}
* @protected
*/
workspace_: Blockly.WorkspaceSvg;
/**
* The default value for this field.
* @type {*}
* @protected
*/
DEFAULT_VALUE: any;
/**
* Serializable fields are saved by the XML renderer, non-serializable fields
* are not. Editable fields should also be serializable.
* @type {boolean}
*/
SERIALIZABLE: boolean;
/**
* Mouse cursor style when over the hotspot that initiates the editor.
*/
CURSOR: any /*missing*/;
/**
* Ensure that the input value casts to a valid string.
* @param {*=} opt_newValue The input value.
* @return {*} A valid string, or null if invalid.
* @protected
*/
doClassValidation_(opt_newValue?: any): any;
/**
* Called by setValue if the text input is not valid. If the field is
* currently being edited it reverts value of the field to the previous
* value while allowing the display text to be handled by the htmlInput_.
* @param {*} _invalidValue The input value that was determined to be invalid.
* This is not used by the text input because its display value is stored on
* the htmlInput_.
* @protected
*/
doValueInvalid_(_invalidValue: any): void;
/**
* Called by setValue if the text input is valid. Updates the value of the
* field, and updates the text of the field if it is not currently being
* edited (i.e. handled by the htmlInput_).
* @param {*} newValue The value to be saved. The default validator guarantees
* that this is a string.
* @protected
*/
doValueUpdate_(newValue: any): void;
/**
* Updates text field to match the colour/style of the block.
* @package
*/
applyColour(): void;
/**
* Updates the colour of the htmlInput given the current validity of the
* field's value.
* @protected
*/
render_(): void;
/**
* Set whether this field is spellchecked by the browser.
* @param {boolean} check True if checked.
*/
setSpellcheck(check: boolean): void;
/**
* Show the inline free-text editor on top of the text.
* @param {Event=} _opt_e Optional mouse event that triggered the field to open,
* or undefined if triggered programmatically.
* @param {boolean=} opt_quietInput True if editor should be created without
* focus. Defaults to false.
* @protected
*/
showEditor_(_opt_e?: Event, opt_quietInput?: boolean): void;
/**
* Create the text input editor widget.
* @return {!HTMLElement} The newly created text input editor.
* @protected
*/
widgetCreate_(): HTMLElement;
/**
* Closes the editor, saves the results, and disposes of any events or
* DOM-references belonging to the editor.
* @protected
*/
widgetDispose_(): void;
/**
* Bind handlers for user input on the text input field's editor.
* @param {!HTMLElement} htmlInput The htmlInput to which event
* handlers will be bound.
* @protected
*/
bindInputEvents_(htmlInput: HTMLElement): void;
/**
* Unbind handlers for user input and workspace size changes.
* @protected
*/
unbindInputEvents_(): void;
/**
* Handle key down to the editor.
* @param {!Event} e Keyboard event.
* @protected
*/
onHtmlInputKeyDown_(e: Event): void;
/**
* Set the HTML input value and the field's internal value. The difference
* between this and ``setValue`` is that this also updates the HTML input
* value whilst editing.
* @param {*} newValue New value.
* @protected
*/
setEditorValue_(newValue: any): void;
/**
* Resize the editor to fit the text.
* @protected
*/
resizeEditor_(): void;
/**
* Transform the provided value into a text to show in the HTML input.
* Override this method if the field's HTML input representation is different
* than the field's value. This should be coupled with an override of
* `getValueFromEditorText_`.
* @param {*} value The value stored in this field.
* @return {string} The text to show on the HTML input.
* @protected
*/
getEditorText_(value: any): string;
/**
* Transform the text received from the HTML input into a value to store
* in this field.
* Override this method if the field's HTML input representation is different
* than the field's value. This should be coupled with an override of
* `getEditorText_`.
* @param {string} text Text received from the HTML input.
* @return {*} The value to store.
* @protected
*/
getValueFromEditorText_(text: string): any;
}
}
declare module Blockly.FieldTextInput {
/**
* Construct a FieldTextInput from a JSON arg object,
* dereferencing any string table references.
* @param {!Object} options A JSON object with options (text, and spellcheck).
* @return {!Blockly.FieldTextInput} The new field instance.
* @package
* @nocollapse
*/
function fromJson(options: Object): Blockly.FieldTextInput;
/**
* Pixel size of input border radius.
* Should match blocklyText's border-radius in CSS.
*/
var BORDERRADIUS: any /*missing*/;
}
declare module Blockly {
class FieldVariable extends FieldVariable__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class FieldVariable__Class extends Blockly.FieldDropdown__Class {
/**
* Class for a variable's dropdown field.
* @param {?string} varName The default name for the variable. If null,
* a unique variable name will be generated.
* @param {Function=} opt_validator A function that is called to validate
* changes to the field's value. Takes in a variable ID & returns a
* validated variable ID, or null to abort the change.
* @param {Array<string>=} opt_variableTypes A list of the types of variables
* to include in the dropdown.
* @param {string=} opt_defaultType The type of variable to create if this
* field's value is not explicitly set. Defaults to ''.
* @param {Object=} opt_config A map of options used to configure the field.
* See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/variable#creation}
* for a list of properties this parameter supports.
* @extends {Blockly.FieldDropdown}
* @constructor
*/
constructor(varName: string, opt_validator?: Function, opt_variableTypes?: string[], opt_defaultType?: string, opt_config?: Object);
/**
* An array of options for a dropdown list,
* or a function which generates these options.
* @type {(!Array<!Array>|
* !function(this:Blockly.FieldDropdown): !Array<!Array>)}
* @protected
*/
menuGenerator_: any[][]|{ (): any[][] };
/**
* The initial variable name passed to this field's constructor, or an
* empty string if a name wasn't provided. Used to create the initial
* variable.
* @type {string}
*/
defaultVariableName: string;
/**
* Serializable fields are saved by the XML renderer, non-serializable fields
* are not. Editable fields should also be serializable.
* @type {boolean}
*/
SERIALIZABLE: boolean;
/**
* Configure the field based on the given map of options.
* @param {!Object} config A map of options to configure the field based on.
* @protected
*/
configure_(config: Object): void;
/**
* Initialize the model for this field if it has not already been initialized.
* If the value has not been set to a variable by the first render, we make up a
* variable rather than let the value be invalid.
* @package
*/
initModel(): void;
/**
* Initialize this field based on the given XML.
* @param {!Element} fieldElement The element containing information about the
* variable field's state.
*/
fromXml(fieldElement: Element): void;
/**
* Serialize this field to XML.
* @param {!Element} fieldElement The element to populate with info about the
* field's state.
* @return {!Element} The element containing info about the field's state.
*/
toXml(fieldElement: Element): Element;
/**
* Attach this field to a block.
* @param {!Blockly.Block} block The block containing this field.
*/
setSourceBlock(block: Blockly.Block): void;
/**
* Get the variable's ID.
* @return {string} Current variable's ID.
*/
getValue(): string;
/**
* Get the text from this field, which is the selected variable's name.
* @return {string} The selected variable's name, or the empty string if no
* variable is selected.
*/
getText(): string;
/**
* Get the variable model for the selected variable.
* Not guaranteed to be in the variable map on the workspace (e.g. if accessed
* after the variable has been deleted).
* @return {?Blockly.VariableModel} The selected variable, or null if none was
* selected.
* @package
*/
getVariable(): Blockly.VariableModel;
/**
* Gets the validation function for this field, or null if not set.
* Returns null if the variable is not set, because validators should not
* run on the initial setValue call, because the field won't be attached to
* a block and workspace at that point.
* @return {?Function} Validation function, or null.
*/
getValidator(): Function;
/**
* Ensure that the ID belongs to a valid variable of an allowed type.
* @param {*=} opt_newValue The ID of the new variable to set.
* @return {?string} The validated ID, or null if invalid.
* @protected
*/
doClassValidation_(opt_newValue?: any): string;
/**
* Update the value of this variable field, as well as its variable and text.
*
* The variable ID should be valid at this point, but if a variable field
* validator returns a bad ID, this could break.
* @param {*} newId The value to be saved.
* @protected
*/
doValueUpdate_(newId: any): void;
/**
* Refreshes the name of the variable by grabbing the name of the model.
* Used when a variable gets renamed, but the ID stays the same. Should only
* be called by the block.
* @package
*/
refreshVariableName(): void;
/**
* Handle the selection of an item in the variable dropdown menu.
* Special case the 'Rename variable...' and 'Delete variable...' options.
* In the rename case, prompt the user for a new name.
* @param {!Blockly.Menu} menu The Menu component clicked.
* @param {!Blockly.MenuItem} menuItem The MenuItem selected within menu.
* @protected
*/
onItemSelected_(menu: Blockly.Menu, menuItem: Blockly.MenuItem): void;
}
}
declare module Blockly.FieldVariable {
/**
* Construct a FieldVariable from a JSON arg object,
* dereferencing any string table references.
* @param {!Object} options A JSON object with options (variable,
* variableTypes, and defaultType).
* @return {!Blockly.FieldVariable} The new field instance.
* @package
* @nocollapse
*/
function fromJson(options: Object): Blockly.FieldVariable;
/**
* Return a sorted list of variable names for variable dropdown menus.
* Include a special option at the end for creating a new variable name.
* @return {!Array<!Array>} Array of variable names/id tuples.
* @this {Blockly.FieldVariable}
*/
function dropdownCreate(): any[][];
}
declare module Blockly {
class Flyout extends Flyout__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Flyout__Class extends Blockly.DeleteArea__Class implements Blockly.IFlyout {
/**
* Class for a flyout.
* @param {!Blockly.Options} workspaceOptions Dictionary of options for the
* workspace.
* @constructor
* @abstract
* @implements {Blockly.IFlyout}
* @extends {Blockly.DeleteArea}
*/
constructor(workspaceOptions: Blockly.Options);
/**
* @type {!Blockly.WorkspaceSvg}
* @protected
*/
workspace_: Blockly.WorkspaceSvg;
/**
* The unique id for this component that is used to register with the
* ComponentManager.
* @type {string}
*/
id: string;
/**
* Is RTL vs LTR.
* @type {boolean}
*/
RTL: boolean;
/**
* Whether the flyout should be laid out horizontally or not.
* @type {boolean}
* @package
*/
horizontalLayout: boolean;
/**
* Position of the toolbox and flyout relative to the workspace.
* @type {number}
* @protected
*/
toolboxPosition_: number;
/**
* List of visible buttons.
* @type {!Array<!Blockly.FlyoutButton>}
* @protected
*/
buttons_: Blockly.FlyoutButton[];
/**
* Width of output tab.
* @type {number}
* @protected
* @const
*/
tabWidth_: number;
/**
* The target workspace
* @type {?Blockly.WorkspaceSvg}
* @package
*/
targetWorkspace: Blockly.WorkspaceSvg;
/**
* Does the flyout automatically close when a block is created?
* @type {boolean}
*/
autoClose: boolean;
/**
* Corner radius of the flyout background.
* @type {number}
* @const
*/
CORNER_RADIUS: number;
/**
* Margin around the edges of the blocks in the flyout.
* @type {number}
* @const
*/
MARGIN: number;
/**
* Gap between items in horizontal flyouts. Can be overridden with the "sep"
* element.
* @const {number}
*/
GAP_X: any /*missing*/;
/**
* Gap between items in vertical flyouts. Can be overridden with the "sep"
* element.
* @const {number}
*/
GAP_Y: any /*missing*/;
/**
* Top/bottom padding between scrollbar and edge of flyout background.
* @type {number}
* @const
*/
SCROLLBAR_MARGIN: number;
/**
* Width of flyout.
* @type {number}
* @protected
*/
width_: number;
/**
* Height of flyout.
* @type {number}
* @protected
*/
height_: number;
/**
* Range of a drag angle from a flyout considered "dragging toward workspace".
* Drags that are within the bounds of this many degrees from the orthogonal
* line to the flyout edge are considered to be "drags toward the workspace".
* Example:
* Flyout Edge Workspace
* [block] / <-within this angle, drags "toward workspace" |
* [block] ---- orthogonal to flyout boundary ---- |
* [block] \ |
* The angle is given in degrees from the orthogonal.
*
* This is used to know when to create a new block and when to scroll the
* flyout. Setting it to 360 means that all drags create a new block.
* @type {number}
* @protected
*/
dragAngleRange_: number;
/**
* Creates the flyout's DOM. Only needs to be called once. The flyout can
* either exist as its own SVG element or be a g element nested inside a
* separate SVG element.
* @param {string|
* !Blockly.utils.Svg<!SVGSVGElement>|
* !Blockly.utils.Svg<!SVGGElement>} tagName The type of tag to
* put the flyout in. This should be <svg> or <g>.
* @return {!SVGElement} The flyout's SVG group.
*/
createDom(tagName: string|Blockly.utils.Svg<SVGSVGElement>|Blockly.utils.Svg<SVGGElement>): SVGElement;
/**
* Initializes the flyout.
* @param {!Blockly.WorkspaceSvg} targetWorkspace The workspace in which to
* create new blocks.
*/
init(targetWorkspace: Blockly.WorkspaceSvg): void;
/**
* Dispose of this flyout.
* Unlink from all DOM elements to prevent memory leaks.
* @suppress {checkTypes}
*/
dispose(): void;
/**
* Get the width of the flyout.
* @return {number} The width of the flyout.
*/
getWidth(): number;
/**
* Get the height of the flyout.
* @return {number} The width of the flyout.
*/
getHeight(): number;
/**
* Get the scale (zoom level) of the flyout. By default,
* this matches the target workspace scale, but this can be overridden.
* @return {number} Flyout workspace scale.
*/
getFlyoutScale(): number;
/**
* Get the workspace inside the flyout.
* @return {!Blockly.WorkspaceSvg} The workspace inside the flyout.
* @package
*/
getWorkspace(): Blockly.WorkspaceSvg;
/**
* Is the flyout visible?
* @return {boolean} True if visible.
*/
isVisible(): boolean;
/**
* Set whether the flyout is visible. A value of true does not necessarily mean
* that the flyout is shown. It could be hidden because its container is hidden.
* @param {boolean} visible True if visible.
*/
setVisible(visible: boolean): void;
/**
* Set whether this flyout's container is visible.
* @param {boolean} visible Whether the container is visible.
*/
setContainerVisible(visible: boolean): void;
/**
* Update the view based on coordinates calculated in position().
* @param {number} width The computed width of the flyout's SVG group
* @param {number} height The computed height of the flyout's SVG group.
* @param {number} x The computed x origin of the flyout's SVG group.
* @param {number} y The computed y origin of the flyout's SVG group.
* @protected
*/
positionAt_(width: number, height: number, x: number, y: number): void;
/**
* Hide and empty the flyout.
*/
hide(): void;
/**
* Show and populate the flyout.
* @param {!Blockly.utils.toolbox.FlyoutDefinition|string} flyoutDef Contents to display
* in the flyout. This is either an array of Nodes, a NodeList, a
* toolbox definition, or a string with the name of the dynamic category.
*/
show(flyoutDef: Blockly.utils.toolbox.FlyoutDefinition|string): void;
/**
* Create a block from the xml and permanently disable any blocks that were
* defined as disabled.
* @param {!Element} blockXml The xml of the block.
* @return {!Blockly.BlockSvg} The block created from the blockXml.
* @protected
*/
createBlock_(blockXml: Element): Blockly.BlockSvg;
/**
* Delete blocks, mats and buttons from a previous showing of the flyout.
* @protected
*/
clearOldBlocks_(): void;
/**
* Add listeners to a block that has been added to the flyout.
* @param {!SVGElement} root The root node of the SVG group the block is in.
* @param {!Blockly.BlockSvg} block The block to add listeners for.
* @param {!SVGElement} rect The invisible rectangle under the block that acts
* as a mat for that block.
* @protected
*/
addBlockListeners_(root: SVGElement, block: Blockly.BlockSvg, rect: SVGElement): void;
/**
* Does this flyout allow you to create a new instance of the given block?
* Used for deciding if a block can be "dragged out of" the flyout.
* @param {!Blockly.BlockSvg} block The block to copy from the flyout.
* @return {boolean} True if you can create a new instance of the block, false
* otherwise.
* @package
*/
isBlockCreatable_(block: Blockly.BlockSvg): boolean;
/**
* Create a copy of this block on the workspace.
* @param {!Blockly.BlockSvg} originalBlock The block to copy from the flyout.
* @return {!Blockly.BlockSvg} The newly created block.
* @throws {Error} if something went wrong with deserialization.
* @package
*/
createBlock(originalBlock: Blockly.BlockSvg): Blockly.BlockSvg;
/**
* Initialize the given button: move it to the correct location,
* add listeners, etc.
* @param {!Blockly.FlyoutButton} button The button to initialize and place.
* @param {number} x The x position of the cursor during this layout pass.
* @param {number} y The y position of the cursor during this layout pass.
* @protected
*/
initFlyoutButton_(button: Blockly.FlyoutButton, x: number, y: number): void;
/**
* Create and place a rectangle corresponding to the given block.
* @param {!Blockly.BlockSvg} block The block to associate the rect to.
* @param {number} x The x position of the cursor during this layout pass.
* @param {number} y The y position of the cursor during this layout pass.
* @param {!{height: number, width: number}} blockHW The height and width of the
* block.
* @param {number} index The index into the mats list where this rect should be
* placed.
* @return {!SVGElement} Newly created SVG element for the rectangle behind the
* block.
* @protected
*/
createRect_(block: Blockly.BlockSvg, x: number, y: number, blockHW: { height: number; width: number }, index: number): SVGElement;
/**
* Move a rectangle to sit exactly behind a block, taking into account tabs,
* hats, and any other protrusions we invent.
* @param {!SVGElement} rect The rectangle to move directly behind the block.
* @param {!Blockly.BlockSvg} block The block the rectangle should be behind.
* @protected
*/
moveRectToBlock_(rect: SVGElement, block: Blockly.BlockSvg): void;
/**
* Reflow blocks and their mats.
*/
reflow(): void;
/**
* @return {boolean} True if this flyout may be scrolled with a scrollbar or by
* dragging.
* @package
*/
isScrollable(): boolean;
/**
* Returns the bounding rectangle of the drag target area in pixel units
* relative to viewport.
* @return {Blockly.utils.Rect} The component's bounding box.
*/
getClientRect(): Blockly.utils.Rect;
/**
* Position the flyout.
* @return {void}
*/
position(): void;
/**
* Determine if a drag delta is toward the workspace, based on the position
* and orientation of the flyout. This is used in determineDragIntention_ to
* determine if a new block should be created or if the flyout should scroll.
* @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
* moved from the position at mouse down, in pixel units.
* @return {boolean} True if the drag is toward the workspace.
* @package
*/
isDragTowardWorkspace(currentDragDeltaXY: Blockly.utils.Coordinate): boolean;
/**
* Sets the translation of the flyout to match the scrollbars.
* @param {!{x:number,y:number}} xyRatio Contains a y property which is a float
* between 0 and 1 specifying the degree of scrolling and a
* similar x property.
* @protected
*/
setMetrics_(xyRatio: { x: number; y: number }): void;
/**
* Lay out the blocks in the flyout.
* @param {!Array<!Object>} contents The blocks and buttons to lay out.
* @param {!Array<number>} gaps The visible gaps between blocks.
* @protected
*/
layout_(contents: Object[], gaps: number[]): void;
/**
* Scroll the flyout.
* @param {!Event} e Mouse wheel scroll event.
* @protected
*/
wheel_(e: Event): void;
/**
* Compute height of flyout. Position mat under each block.
* For RTL: Lay out the blocks right-aligned.
* @return {void}
* @protected
*/
reflowInternal_(): void;
/**
* Calculates the x coordinate for the flyout position.
* @return {number} X coordinate.
*/
getX(): number;
/**
* Calculates the y coordinate for the flyout position.
* @return {number} Y coordinate.
*/
getY(): number;
}
}
declare module Blockly {
class FlyoutButton extends FlyoutButton__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class FlyoutButton__Class {
/**
* Class for a button in the flyout.
* @param {!Blockly.WorkspaceSvg} workspace The workspace in which to place this
* button.
* @param {!Blockly.WorkspaceSvg} targetWorkspace The flyout's target workspace.
* @param {!Blockly.utils.toolbox.ButtonOrLabelInfo} json
* The JSON specifying the label/button.
* @param {boolean} isLabel Whether this button should be styled as a label.
* @constructor
* @package
*/
constructor(workspace: Blockly.WorkspaceSvg, targetWorkspace: Blockly.WorkspaceSvg, json: Blockly.utils.toolbox.ButtonOrLabelInfo, isLabel: boolean);
/**
* The JSON specifying the label / button.
* @type {!Blockly.utils.toolbox.ButtonOrLabelInfo}
*/
info: Blockly.utils.toolbox.ButtonOrLabelInfo;
/**
* The width of the button's rect.
* @type {number}
*/
width: number;
/**
* The height of the button's rect.
* @type {number}
*/
height: number;
/**
* Create the button elements.
* @return {!SVGElement} The button's SVG group.
*/
createDom(): SVGElement;
/**
* Correctly position the flyout button and make it visible.
*/
show(): void;
/**
* Move the button to the given x, y coordinates.
* @param {number} x The new x coordinate.
* @param {number} y The new y coordinate.
*/
moveTo(x: number, y: number): void;
/**
* @return {boolean} Whether or not the button is a label.
*/
isLabel(): boolean;
/**
* Location of the button.
* @return {!Blockly.utils.Coordinate} x, y coordinates.
* @package
*/
getPosition(): Blockly.utils.Coordinate;
/**
* @return {string} Text of the button.
*/
getButtonText(): string;
/**
* Get the button's target workspace.
* @return {!Blockly.WorkspaceSvg} The target workspace of the flyout where this
* button resides.
*/
getTargetWorkspace(): Blockly.WorkspaceSvg;
/**
* Dispose of this button.
*/
dispose(): void;
}
}
declare module Blockly.FlyoutButton {
/**
* The horizontal margin around the text in the button.
*/
var MARGIN_X: any /*missing*/;
/**
* The vertical margin around the text in the button.
*/
var MARGIN_Y: any /*missing*/;
}
declare module Blockly {
class HorizontalFlyout extends HorizontalFlyout__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class HorizontalFlyout__Class extends Blockly.Flyout__Class {
/**
* Class for a flyout.
* @param {!Blockly.Options} workspaceOptions Dictionary of options for the
* workspace.
* @extends {Blockly.Flyout}
* @constructor
*/
constructor(workspaceOptions: Blockly.Options);
/**
* Sets the translation of the flyout to match the scrollbars.
* @param {!{x:number,y:number}} xyRatio Contains a y property which is a float
* between 0 and 1 specifying the degree of scrolling and a
* similar x property.
* @protected
*/
setMetrics_(xyRatio: { x: number; y: number }): void;
/**
* Calculates the x coordinate for the flyout position.
* @return {number} X coordinate.
*/
getX(): number;
/**
* Calculates the y coordinate for the flyout position.
* @return {number} Y coordinate.
*/
getY(): number;
/**
* Move the flyout to the edge of the workspace.
*/
position(): void;
/**
* Scroll the flyout to the top.
*/
scrollToStart(): void;
/**
* Scroll the flyout.
* @param {!Event} e Mouse wheel scroll event.
* @protected
*/
wheel_(e: Event): void;
/**
* Lay out the blocks in the flyout.
* @param {!Array<!Object>} contents The blocks and buttons to lay out.
* @param {!Array<number>} gaps The visible gaps between blocks.
* @protected
*/
layout_(contents: Object[], gaps: number[]): void;
/**
* Determine if a drag delta is toward the workspace, based on the position
* and orientation of the flyout. This is used in determineDragIntention_ to
* determine if a new block should be created or if the flyout should scroll.
* @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
* moved from the position at mouse down, in pixel units.
* @return {boolean} True if the drag is toward the workspace.
* @package
*/
isDragTowardWorkspace(currentDragDeltaXY: Blockly.utils.Coordinate): boolean;
/**
* Returns the bounding rectangle of the drag target area in pixel units
* relative to viewport.
* @return {?Blockly.utils.Rect} The component's bounding box. Null if drag
* target area should be ignored.
*/
getClientRect(): Blockly.utils.Rect;
/**
* Compute height of flyout. Position mat under each block.
* For RTL: Lay out the blocks right-aligned.
* @protected
*/
reflowInternal_(): void;
}
}
declare module Blockly {
class VerticalFlyout extends VerticalFlyout__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class VerticalFlyout__Class extends Blockly.Flyout__Class {
/**
* Class for a flyout.
* @param {!Blockly.Options} workspaceOptions Dictionary of options for the
* workspace.
* @extends {Blockly.Flyout}
* @constructor
*/
constructor(workspaceOptions: Blockly.Options);
/**
* Sets the translation of the flyout to match the scrollbars.
* @param {!{x:number,y:number}} xyRatio Contains a y property which is a float
* between 0 and 1 specifying the degree of scrolling and a
* similar x property.
* @protected
*/
setMetrics_(xyRatio: { x: number; y: number }): void;
/**
* Calculates the x coordinate for the flyout position.
* @return {number} X coordinate.
*/
getX(): number;
/**
* Calculates the y coordinate for the flyout position.
* @return {number} Y coordinate.
*/
getY(): number;
/**
* Move the flyout to the edge of the workspace.
*/
position(): void;
/**
* Scroll the flyout to the top.
*/
scrollToStart(): void;
/**
* Scroll the flyout.
* @param {!Event} e Mouse wheel scroll event.
* @protected
*/
wheel_(e: Event): void;
/**
* Lay out the blocks in the flyout.
* @param {!Array<!Object>} contents The blocks and buttons to lay out.
* @param {!Array<number>} gaps The visible gaps between blocks.
* @protected
*/
layout_(contents: Object[], gaps: number[]): void;
/**
* Determine if a drag delta is toward the workspace, based on the position
* and orientation of the flyout. This is used in determineDragIntention_ to
* determine if a new block should be created or if the flyout should scroll.
* @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
* moved from the position at mouse down, in pixel units.
* @return {boolean} True if the drag is toward the workspace.
* @package
*/
isDragTowardWorkspace(currentDragDeltaXY: Blockly.utils.Coordinate): boolean;
/**
* Returns the bounding rectangle of the drag target area in pixel units
* relative to viewport.
* @return {?Blockly.utils.Rect} The component's bounding box. Null if drag
* target area should be ignored.
*/
getClientRect(): Blockly.utils.Rect;
/**
* Compute width of flyout. Position mat under each block.
* For RTL: Lay out the blocks and buttons to be right-aligned.
* @protected
*/
reflowInternal_(): void;
}
}
declare module Blockly.VerticalFlyout {
/**
* The name of the vertical flyout in the registry.
* @type {string}
*/
var registryName: string;
}
declare module Blockly {
class Generator extends Generator__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Generator__Class {
/**
* Class for a code generator that translates the blocks into a language.
* @param {string} name Language name of this generator.
* @constructor
*/
constructor(name: string);
/**
* Arbitrary code to inject into locations that risk causing infinite loops.
* Any instances of '%1' will be replaced by the block ID that failed.
* E.g. ' checkTimeout(%1);\n'
* @type {?string}
*/
INFINITE_LOOP_TRAP: string;
/**
* Arbitrary code to inject before every statement.
* Any instances of '%1' will be replaced by the block ID of the statement.
* E.g. 'highlight(%1);\n'
* @type {?string}
*/
STATEMENT_PREFIX: string;
/**
* Arbitrary code to inject after every statement.
* Any instances of '%1' will be replaced by the block ID of the statement.
* E.g. 'highlight(%1);\n'
* @type {?string}
*/
STATEMENT_SUFFIX: string;
/**
* The method of indenting. Defaults to two spaces, but language generators
* may override this to increase indent or change to tabs.
* @type {string}
*/
INDENT: string;
/**
* Maximum length for a comment before wrapping. Does not account for
* indenting level.
* @type {number}
*/
COMMENT_WRAP: number;
/**
* List of outer-inner pairings that do NOT require parentheses.
* @type {!Array<!Array<number>>}
*/
ORDER_OVERRIDES: number[][];
/**
* Whether the init method has been called.
* Generators that set this flag to false after creation and true in init
* will cause blockToCode to emit a warning if the generator has not been
* initialized. If this flag is untouched, it will have no effect.
* @type {?boolean}
*/
isInitialized: boolean;
/**
* Generate code for all blocks in the workspace to the specified language.
* @param {!Blockly.Workspace=} workspace Workspace to generate code from.
* @return {string} Generated code.
*/
workspaceToCode(workspace?: Blockly.Workspace): string;
/**
* Prepend a common prefix onto each line of code.
* Intended for indenting code or adding comment markers.
* @param {string} text The lines of code.
* @param {string} prefix The common prefix.
* @return {string} The prefixed lines of code.
*/
prefixLines(text: string, prefix: string): string;
/**
* Recursively spider a tree of blocks, returning all their comments.
* @param {!Blockly.Block} block The block from which to start spidering.
* @return {string} Concatenated list of comments.
*/
allNestedComments(block: Blockly.Block): string;
/**
* Generate code for the specified block (and attached blocks).
* The generator must be initialized before calling this function.
* @param {Blockly.Block} block The block to generate code for.
* @param {boolean=} opt_thisOnly True to generate code for only this statement.
* @return {string|!Array} For statement blocks, the generated code.
* For value blocks, an array containing the generated code and an
* operator order value. Returns '' if block is null.
*/
blockToCode(block: Blockly.Block, opt_thisOnly?: boolean): string|any[];
/**
* Generate code representing the specified value input.
* @param {!Blockly.Block} block The block containing the input.
* @param {string} name The name of the input.
* @param {number} outerOrder The maximum binding strength (minimum order value)
* of any operators adjacent to "block".
* @return {string} Generated code or '' if no blocks are connected or the
* specified input does not exist.
*/
valueToCode(block: Blockly.Block, name: string, outerOrder: number): string;
/**
* Generate a code string representing the blocks attached to the named
* statement input. Indent the code.
* This is mainly used in generators. When trying to generate code to evaluate
* look at using workspaceToCode or blockToCode.
* @param {!Blockly.Block} block The block containing the input.
* @param {string} name The name of the input.
* @return {string} Generated code or '' if no blocks are connected.
*/
statementToCode(block: Blockly.Block, name: string): string;
/**
* Add an infinite loop trap to the contents of a loop.
* Add statement suffix at the start of the loop block (right after the loop
* statement executes), and a statement prefix to the end of the loop block
* (right before the loop statement executes).
* @param {string} branch Code for loop contents.
* @param {!Blockly.Block} block Enclosing block.
* @return {string} Loop contents, with infinite loop trap added.
*/
addLoopTrap(branch: string, block: Blockly.Block): string;
/**
* Inject a block ID into a message to replace '%1'.
* Used for STATEMENT_PREFIX, STATEMENT_SUFFIX, and INFINITE_LOOP_TRAP.
* @param {string} msg Code snippet with '%1'.
* @param {!Blockly.Block} block Block which has an ID.
* @return {string} Code snippet with ID.
*/
injectId(msg: string, block: Blockly.Block): string;
/**
* Comma-separated list of reserved words.
* @type {string}
* @protected
*/
RESERVED_WORDS_: string;
/**
* Add one or more words to the list of reserved words for this language.
* @param {string} words Comma-separated list of words to add to the list.
* No spaces. Duplicates are ok.
*/
addReservedWords(words: string): void;
/**
* This is used as a placeholder in functions defined using
* Blockly.Generator.provideFunction_. It must not be legal code that could
* legitimately appear in a function definition (or comment), and it must
* not confuse the regular expression parser.
* @type {string}
* @protected
*/
FUNCTION_NAME_PLACEHOLDER_: string;
/**
* A dictionary of definitions to be printed before the code.
* @type {!Object|undefined}
* @protected
*/
definitions_: Object|any /*undefined*/;
/**
* A dictionary mapping desired function names in definitions_ to actual
* function names (to avoid collisions with user functions).
* @type {!Object|undefined}
* @protected
*/
functionNames_: Object|any /*undefined*/;
/**
* A database of variable and procedure names.
* @type {!Blockly.Names|undefined}
* @protected
*/
nameDB_: Blockly.Names|any /*undefined*/;
/**
* Define a developer-defined function (not a user-defined procedure) to be
* included in the generated code. Used for creating private helper functions.
* The first time this is called with a given desiredName, the code is
* saved and an actual name is generated. Subsequent calls with the
* same desiredName have no effect but have the same return value.
*
* It is up to the caller to make sure the same desiredName is not
* used for different helper functions (e.g. use "colourRandom" and
* "listRandom", not "random"). There is no danger of colliding with reserved
* words, or user-defined variable or procedure names.
*
* The code gets output when Blockly.Generator.finish() is called.
*
* @param {string} desiredName The desired name of the function
* (e.g. mathIsPrime).
* @param {!Array<string>} code A list of statements. Use ' ' for indents.
* @return {string} The actual name of the new function. This may differ
* from desiredName if the former has already been taken by the user.
* @protected
*/
provideFunction_(desiredName: string, code: string[]): string;
/**
* Hook for code to run before code generation starts.
* Subclasses may override this, e.g. to initialise the database of variable
* names.
* @param {!Blockly.Workspace} _workspace Workspace to generate code from.
*/
init(_workspace: Blockly.Workspace): void;
/**
* Common tasks for generating code from blocks. This is called from
* blockToCode and is called on every block, not just top level blocks.
* Subclasses may override this, e.g. to generate code for statements following
* the block, or to handle comments for the specified block and any connected
* value blocks.
* @param {!Blockly.Block} _block The current block.
* @param {string} code The code created for this block.
* @param {boolean=} _opt_thisOnly True to generate code for only this
* statement.
* @return {string} Code with comments and subsequent blocks added.
* @protected
*/
scrub_(_block: Blockly.Block, code: string, _opt_thisOnly?: boolean): string;
/**
* Hook for code to run at end of code generation.
* Subclasses may override this, e.g. to prepend the generated code with import
* statements or variable definitions.
* @param {string} code Generated code.
* @return {string} Completed code.
*/
finish(code: string): string;
/**
* Naked values are top-level blocks with outputs that aren't plugged into
* anything.
* Subclasses may override this, e.g. if their language does not allow
* naked values.
* @param {string} line Line of generated code.
* @return {string} Legal line of code.
*/
scrubNakedValue(line: string): string;
}
}
declare module Blockly {
class Gesture extends Gesture__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Gesture__Class {
/**
* Class for one gesture.
* @param {!Event} e The event that kicked off this gesture.
* @param {!Blockly.WorkspaceSvg} creatorWorkspace The workspace that created
* this gesture and has a reference to it.
* @constructor
*/
constructor(e: Event, creatorWorkspace: Blockly.WorkspaceSvg);
/**
* The workspace that the gesture started on. There may be multiple
* workspaces on a page; this is more accurate than using
* Blockly.getMainWorkspace().
* @type {Blockly.WorkspaceSvg}
* @protected
*/
startWorkspace_: Blockly.WorkspaceSvg;
/**
* A handle to use to unbind a mouse move listener at the end of a drag.
* Opaque data returned from Blockly.bindEventWithChecks_.
* @type {?Blockly.browserEvents.Data}
* @protected
*/
onMoveWrapper_: Blockly.browserEvents.Data;
/**
* A handle to use to unbind a mouse up listener at the end of a drag.
* Opaque data returned from Blockly.bindEventWithChecks_.
* @type {?Blockly.browserEvents.Data}
* @protected
*/
onUpWrapper_: Blockly.browserEvents.Data;
/**
* Boolean used internally to break a cycle in disposal.
* @type {boolean}
* @protected
*/
isEnding_: boolean;
/**
* Sever all links from this object.
* @package
*/
dispose(): void;
/**
* Start a gesture: update the workspace to indicate that a gesture is in
* progress and bind mousemove and mouseup handlers.
* @param {!Event} e A mouse down or touch start event.
* @package
*/
doStart(e: Event): void;
/**
* Bind gesture events.
* @param {!Event} e A mouse down or touch start event.
* @package
*/
bindMouseEvents(e: Event): void;
/**
* Handle a mouse move or touch move event.
* @param {!Event} e A mouse move or touch move event.
* @package
*/
handleMove(e: Event): void;
/**
* Handle a mouse up or touch end event.
* @param {!Event} e A mouse up or touch end event.
* @package
*/
handleUp(e: Event): void;
/**
* Cancel an in-progress gesture. If a workspace or block drag is in progress,
* end the drag at the most recent location.
* @package
*/
cancel(): void;
/**
* Handle a real or faked right-click event by showing a context menu.
* @param {!Event} e A mouse move or touch move event.
* @package
*/
handleRightClick(e: Event): void;
/**
* Handle a mousedown/touchstart event on a workspace.
* @param {!Event} e A mouse down or touch start event.
* @param {!Blockly.WorkspaceSvg} ws The workspace the event hit.
* @package
*/
handleWsStart(e: Event, ws: Blockly.WorkspaceSvg): void;
/**
* Handle a mousedown/touchstart event on a flyout.
* @param {!Event} e A mouse down or touch start event.
* @param {!Blockly.IFlyout} flyout The flyout the event hit.
* @package
*/
handleFlyoutStart(e: Event, flyout: Blockly.IFlyout): void;
/**
* Handle a mousedown/touchstart event on a block.
* @param {!Event} e A mouse down or touch start event.
* @param {!Blockly.BlockSvg} block The block the event hit.
* @package
*/
handleBlockStart(e: Event, block: Blockly.BlockSvg): void;
/**
* Handle a mousedown/touchstart event on a bubble.
* @param {!Event} e A mouse down or touch start event.
* @param {!Blockly.IBubble} bubble The bubble the event hit.
* @package
*/
handleBubbleStart(e: Event, bubble: Blockly.IBubble): void;
/**
* Record the field that a gesture started on.
* @param {Blockly.Field} field The field the gesture started on.
* @package
*/
setStartField(field: Blockly.Field): void;
/**
* Record the bubble that a gesture started on
* @param {Blockly.IBubble} bubble The bubble the gesture started on.
* @package
*/
setStartBubble(bubble: Blockly.IBubble): void;
/**
* Record the block that a gesture started on, and set the target block
* appropriately.
* @param {Blockly.BlockSvg} block The block the gesture started on.
* @package
*/
setStartBlock(block: Blockly.BlockSvg): void;
/**
* Whether this gesture is a drag of either a workspace or block.
* This function is called externally to block actions that cannot be taken
* mid-drag (e.g. using the keyboard to delete the selected blocks).
* @return {boolean} True if this gesture is a drag of a workspace or block.
* @package
*/
isDragging(): boolean;
/**
* Whether this gesture has already been started. In theory every mouse down
* has a corresponding mouse up, but in reality it is possible to lose a
* mouse up, leaving an in-process gesture hanging.
* @return {boolean} Whether this gesture was a click on a workspace.
* @package
*/
hasStarted(): boolean;
/**
* Get a list of the insertion markers that currently exist. Block drags have
* 0, 1, or 2 insertion markers.
* @return {!Array<!Blockly.BlockSvg>} A possibly empty list of insertion
* marker blocks.
* @package
*/
getInsertionMarkers(): Blockly.BlockSvg[];
/**
* Gets the current dragger if an item is being dragged. Null if nothing is
* being dragged.
* @return {!Blockly.WorkspaceDragger|!Blockly.BubbleDragger|!Blockly.IBlockDragger|null}
* The dragger that is currently in use or null if no drag is in progress.
*/
getCurrentDragger(): Blockly.WorkspaceDragger|Blockly.BubbleDragger|Blockly.IBlockDragger|any /*null*/;
}
}
declare module Blockly.Gesture {
/**
* Is a drag or other gesture currently in progress on any workspace?
* @return {boolean} True if gesture is occurring.
*/
function inProgress(): boolean;
}
declare module Blockly {
class Grid extends Grid__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Grid__Class {
/**
* Class for a workspace's grid.
* @param {!SVGElement} pattern The grid's SVG pattern, created during
* injection.
* @param {!Object} options A dictionary of normalized options for the grid.
* See grid documentation:
* https://developers.google.com/blockly/guides/configure/web/grid
* @constructor
*/
constructor(pattern: SVGElement, options: Object);
/**
* Dispose of this grid and unlink from the DOM.
* @package
* @suppress {checkTypes}
*/
dispose(): void;
/**
* Whether blocks should snap to the grid, based on the initial configuration.
* @return {boolean} True if blocks should snap, false otherwise.
* @package
*/
shouldSnap(): boolean;
/**
* Get the spacing of the grid points (in px).
* @return {number} The spacing of the grid points.
* @package
*/
getSpacing(): number;
/**
* Get the ID of the pattern element, which should be randomized to avoid
* conflicts with other Blockly instances on the page.
* @return {string} The pattern ID.
* @package
*/
getPatternId(): string;
/**
* Update the grid with a new scale.
* @param {number} scale The new workspace scale.
* @package
*/
update(scale: number): void;
/**
* Move the grid to a new x and y position, and make sure that change is
* visible.
* @param {number} x The new x position of the grid (in px).
* @param {number} y The new y position of the grid (in px).
* @package
*/
moveTo(x: number, y: number): void;
}
}
declare module Blockly.Grid {
/**
* Create the DOM for the grid described by options.
* @param {string} rnd A random ID to append to the pattern's ID.
* @param {!Object} gridOptions The object containing grid configuration.
* @param {!SVGElement} defs The root SVG element for this workspace's defs.
* @return {!SVGElement} The SVG element for the grid pattern.
* @package
*/
function createDom(rnd: string, gridOptions: Object, defs: SVGElement): SVGElement;
}
declare module Blockly {
class Icon extends Icon__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Icon__Class {
/**
* Class for an icon.
* @param {Blockly.BlockSvg} block The block associated with this icon.
* @constructor
* @abstract
*/
constructor(block: Blockly.BlockSvg);
/**
* The block this icon is attached to.
* @type {Blockly.BlockSvg}
* @protected
*/
block_: Blockly.BlockSvg;
/**
* The icon SVG group.
* @type {?SVGGElement}
*/
iconGroup_: SVGGElement;
/**
* Does this icon get hidden when the block is collapsed.
*/
collapseHidden: any /*missing*/;
/**
* Height and width of icons.
*/
SIZE: any /*missing*/;
/**
* Bubble UI (if visible).
* @type {?Blockly.Bubble}
* @protected
*/
bubble_: Blockly.Bubble;
/**
* Absolute coordinate of icon's center.
* @type {?Blockly.utils.Coordinate}
* @protected
*/
iconXY_: Blockly.utils.Coordinate;
/**
* Create the icon on the block.
*/
createIcon(): void;
/**
* Dispose of this icon.
*/
dispose(): void;
/**
* Add or remove the UI indicating if this icon may be clicked or not.
*/
updateEditable(): void;
/**
* Is the associated bubble visible?
* @return {boolean} True if the bubble is visible.
*/
isVisible(): boolean;
/**
* Clicking on the icon toggles if the bubble is visible.
* @param {!Event} e Mouse click event.
* @protected
*/
iconClick_(e: Event): void;
/**
* Change the colour of the associated bubble to match its block.
*/
applyColour(): void;
/**
* Notification that the icon has moved. Update the arrow accordingly.
* @param {!Blockly.utils.Coordinate} xy Absolute location in workspace coordinates.
*/
setIconLocation(xy: Blockly.utils.Coordinate): void;
/**
* Notification that the icon has moved, but we don't really know where.
* Recompute the icon's location from scratch.
*/
computeIconLocation(): void;
/**
* Returns the center of the block's icon relative to the surface.
* @return {?Blockly.utils.Coordinate} Object with x and y properties in
* workspace coordinates.
*/
getIconLocation(): Blockly.utils.Coordinate;
/**
* Get the size of the icon as used for rendering.
* This differs from the actual size of the icon, because it bulges slightly
* out of its row rather than increasing the height of its row.
* @return {!Blockly.utils.Size} Height and width.
*/
getCorrectedSize(): Blockly.utils.Size;
/**
* Draw the icon.
* @param {!Element} group The icon group.
* @protected
*/
drawIcon_(group: Element): void;
/**
* Show or hide the icon.
* @param {boolean} visible True if the icon should be visible.
*/
setVisible(visible: boolean): void;
}
}
declare module Blockly {
/**
* Inject a Blockly editor into the specified container element (usually a div).
* @param {Element|string} container Containing element, or its ID,
* or a CSS selector.
* @param {Blockly.BlocklyOptions=} opt_options Optional dictionary of options.
* @return {!Blockly.WorkspaceSvg} Newly created main workspace.
*/
function inject(container: Element|string, opt_options?: Blockly.BlocklyOptions): Blockly.WorkspaceSvg;
/**
* Bumps the given object that has passed out of bounds.
* @param {!Blockly.WorkspaceSvg} workspace The workspace containing the object.
* @param {!Blockly.MetricsManager.ContainerRegion} scrollMetrics Scroll metrics
* in workspace coordinates.
* @param {!Blockly.IBoundedElement} object The object to bump.
* @return {boolean} True if block was bumped.
* @package
*/
function bumpObjectIntoBounds_(workspace: Blockly.WorkspaceSvg, scrollMetrics: Blockly.MetricsManager.ContainerRegion, object: Blockly.IBoundedElement): boolean;
}
declare module Blockly {
class Input extends Input__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Input__Class {
/**
* Class for an input with an optional field.
* @param {number} type The type of the input.
* @param {string} name Language-neutral identifier which may used to find this
* input again.
* @param {!Blockly.Block} block The block containing this input.
* @param {Blockly.Connection} connection Optional connection for this input.
* @constructor
*/
constructor(type: number, name: string, block: Blockly.Block, connection: Blockly.Connection);
/** @type {number} */
type: number;
/** @type {string} */
name: string;
/** @type {Blockly.Connection} */
connection: Blockly.Connection;
/** @type {!Array<!Blockly.Field>} */
fieldRow: Blockly.Field[];
/**
* Alignment of input's fields (left, right or centre).
* @type {number}
*/
align: number;
/**
* Get the source block for this input.
* @return {?Blockly.Block} The source block, or null if there is none.
*/
getSourceBlock(): Blockly.Block;
/**
* Add a field (or label from string), and all prefix and suffix fields, to the
* end of the input's field row.
* @param {string|!Blockly.Field} field Something to add as a field.
* @param {string=} opt_name Language-neutral identifier which may used to find
* this field again. Should be unique to the host block.
* @return {!Blockly.Input} The input being append to (to allow chaining).
*/
appendField(field: string|Blockly.Field, opt_name?: string): Blockly.Input;
/**
* Inserts a field (or label from string), and all prefix and suffix fields, at
* the location of the input's field row.
* @param {number} index The index at which to insert field.
* @param {string|!Blockly.Field} field Something to add as a field.
* @param {string=} opt_name Language-neutral identifier which may used to find
* this field again. Should be unique to the host block.
* @return {number} The index following the last inserted field.
*/
insertFieldAt(index: number, field: string|Blockly.Field, opt_name?: string): number;
/**
* Remove a field from this input.
* @param {string} name The name of the field.
* @param {boolean=} opt_quiet True to prevent an error if field is not present.
* @return {boolean} True if operation succeeds, false if field is not present
* and opt_quiet is true.
* @throws {Error} if the field is not present and opt_quiet is false.
*/
removeField(name: string, opt_quiet?: boolean): boolean;
/**
* Gets whether this input is visible or not.
* @return {boolean} True if visible.
*/
isVisible(): boolean;
/**
* Sets whether this input is visible or not.
* Should only be used to collapse/uncollapse a block.
* @param {boolean} visible True if visible.
* @return {!Array<!Blockly.BlockSvg>} List of blocks to render.
* @package
*/
setVisible(visible: boolean): Blockly.BlockSvg[];
/**
* Mark all fields on this input as dirty.
* @package
*/
markDirty(): void;
/**
* Change a connection's compatibility.
* @param {string|Array<string>|null} check Compatible value type or
* list of value types. Null if all types are compatible.
* @return {!Blockly.Input} The input being modified (to allow chaining).
*/
setCheck(check: string|string[]|any /*null*/): Blockly.Input;
/**
* Change the alignment of the connection's field(s).
* @param {number} align One of the values of Blockly.constants.ALIGN.
* In RTL mode directions are reversed, and ALIGN.RIGHT aligns to the left.
* @return {!Blockly.Input} The input being modified (to allow chaining).
*/
setAlign(align: number): Blockly.Input;
/**
* Changes the connection's shadow block.
* @param {?Element} shadow DOM representation of a block or null.
* @return {!Blockly.Input} The input being modified (to allow chaining).
*/
setShadowDom(shadow: Element): Blockly.Input;
/**
* Returns the XML representation of the connection's shadow block.
* @return {?Element} Shadow DOM representation of a block or null.
*/
getShadowDom(): Element;
/**
* Initialize the fields on this input.
*/
init(): void;
/**
* Sever all links to this input.
* @suppress {checkTypes}
*/
dispose(): void;
}
}
declare module Blockly {
/**
* Enum for the type of a connection or input.
* @enum {number}
*/
enum inputTypes { VALUE, STATEMENT, DUMMY }
}
declare module Blockly {
class InsertionMarkerManager extends InsertionMarkerManager__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class InsertionMarkerManager__Class {
/**
* Class that controls updates to connections during drags. It is primarily
* responsible for finding the closest eligible connection and highlighting or
* unhiglighting it as needed during a drag.
* @param {!Blockly.BlockSvg} block The top block in the stack being dragged.
* @constructor
*/
constructor(block: Blockly.BlockSvg);
/**
* Sever all links from this object.
* @package
*/
dispose(): void;
/**
* Update the available connections for the top block. These connections can
* change if a block is unplugged and the stack is healed.
* @package
*/
updateAvailableConnections(): void;
/**
* Return whether the block would be deleted if dropped immediately, based on
* information from the most recent move event.
* @return {boolean} True if the block would be deleted if dropped immediately.
* @package
*/
wouldDeleteBlock(): boolean;
/**
* Return whether the block would be connected if dropped immediately, based on
* information from the most recent move event.
* @return {boolean} True if the block would be connected if dropped
* immediately.
* @package
*/
wouldConnectBlock(): boolean;
/**
* Connect to the closest connection and render the results.
* This should be called at the end of a drag.
* @package
*/
applyConnections(): void;
/**
* Update connections based on the most recent move location.
* @param {!Blockly.utils.Coordinate} dxy Position relative to drag start,
* in workspace units.
* @param {?Blockly.IDragTarget} dragTarget The drag target that the block is
* currently over.
* @package
*/
update(dxy: Blockly.utils.Coordinate, dragTarget: Blockly.IDragTarget): void;
/**
* Get a list of the insertion markers that currently exist. Drags have 0, 1,
* or 2 insertion markers.
* @return {!Array<!Blockly.BlockSvg>} A possibly empty list of insertion
* marker blocks.
* @package
*/
getInsertionMarkers(): Blockly.BlockSvg[];
}
}
declare module Blockly.InsertionMarkerManager {
/**
* An enum describing different kinds of previews the InsertionMarkerManager
* could display.
* @enum {number}
*/
enum PREVIEW_TYPE { INSERTION_MARKER, INPUT_OUTLINE, REPLACEMENT_FADE }
/**
* An error message to throw if the block created by createMarkerBlock_ is
* missing any components.
* @type {string}
* @const
*/
var DUPLICATE_BLOCK_ERROR: string;
}
declare module Blockly {
class MarkerManager extends MarkerManager__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class MarkerManager__Class {
/**
* Class to manage the multiple markers and the cursor on a workspace.
* @param {!Blockly.WorkspaceSvg} workspace The workspace for the marker manager.
* @constructor
* @package
*/
constructor(workspace: Blockly.WorkspaceSvg);
/**
* Register the marker by adding it to the map of markers.
* @param {string} id A unique identifier for the marker.
* @param {!Blockly.Marker} marker The marker to register.
*/
registerMarker(id: string, marker: Blockly.Marker): void;
/**
* Unregister the marker by removing it from the map of markers.
* @param {string} id The ID of the marker to unregister.
*/
unregisterMarker(id: string): void;
/**
* Get the cursor for the workspace.
* @return {?Blockly.Cursor} The cursor for this workspace.
*/
getCursor(): Blockly.Cursor;
/**
* Get a single marker that corresponds to the given ID.
* @param {string} id A unique identifier for the marker.
* @return {?Blockly.Marker} The marker that corresponds to the given ID,
* or null if none exists.
*/
getMarker(id: string): Blockly.Marker;
/**
* Sets the cursor and initializes the drawer for use with keyboard navigation.
* @param {Blockly.Cursor} cursor The cursor used to move around this workspace.
*/
setCursor(cursor: Blockly.Cursor): void;
/**
* Add the cursor SVG to this workspace SVG group.
* @param {?SVGElement} cursorSvg The SVG root of the cursor to be added to the
* workspace SVG group.
* @package
*/
setCursorSvg(cursorSvg: SVGElement): void;
/**
* Add the marker SVG to this workspaces SVG group.
* @param {?SVGElement} markerSvg The SVG root of the marker to be added to the
* workspace SVG group.
* @package
*/
setMarkerSvg(markerSvg: SVGElement): void;
/**
* Redraw the attached cursor SVG if needed.
* @package
*/
updateMarkers(): void;
/**
* Dispose of the marker manager.
* Go through and delete all markers associated with this marker manager.
* @suppress {checkTypes}
* @package
*/
dispose(): void;
}
}
declare module Blockly.MarkerManager {
/**
* The name of the local marker.
* @type {string}
* @const
*/
var LOCAL_MARKER: string;
}
declare module Blockly {
class Menu extends Menu__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Menu__Class {
/**
* A basic menu class.
* @constructor
*/
constructor();
/**
* Coordinates of the mousedown event that caused this menu to open. Used to
* prevent the consequent mouseup event due to a simple click from activating
* a menu item immediately.
* @type {?Blockly.utils.Coordinate}
* @package
*/
openingCoords: Blockly.utils.Coordinate;
/**
* Add a new menu item to the bottom of this menu.
* @param {!Blockly.MenuItem} menuItem Menu item to append.
*/
addChild(menuItem: Blockly.MenuItem): void;
/**
* Creates the menu DOM.
* @param {!Element} container Element upon which to append this menu.
*/
render(container: Element): void;
/**
* Gets the menu's element.
* @return {?Element} The DOM element.
* @package
*/
getElement(): Element;
/**
* Focus the menu element.
* @package
*/
focus(): void;
/**
* Set the menu accessibility role.
* @param {!Blockly.utils.aria.Role} roleName role name.
* @package
*/
setRole(roleName: Blockly.utils.aria.Role): void;
/**
* Dispose of this menu.
*/
dispose(): void;
/**
* Highlights the given menu item, or clears highlighting if null.
* @param {?Blockly.MenuItem} item Item to highlight, or null.
* @package
*/
setHighlighted(item: Blockly.MenuItem): void;
/**
* Highlights the next highlightable item (or the first if nothing is currently
* highlighted).
* @package
*/
highlightNext(): void;
/**
* Highlights the previous highlightable item (or the last if nothing is
* currently highlighted).
* @package
*/
highlightPrevious(): void;
/**
* Get the size of a rendered menu.
* @return {!Blockly.utils.Size} Object with width and height properties.
* @package
*/
getSize(): Blockly.utils.Size;
}
}
declare module Blockly {
class MenuItem extends MenuItem__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class MenuItem__Class {
/**
* Class representing an item in a menu.
*
* @param {string|!HTMLElement} content Text caption to display as the content
* of the item, or a HTML element to display.
* @param {string=} opt_value Data/model associated with the menu item.
* @constructor
*/
constructor(content: string|HTMLElement, opt_value?: string);
/**
* Creates the menuitem's DOM.
* @return {!Element} Completed DOM.
*/
createDom(): Element;
/**
* Dispose of this menu item.
*/
dispose(): void;
/**
* Gets the menu item's element.
* @return {?Element} The DOM element.
* @package
*/
getElement(): Element;
/**
* Gets the unique ID for this menu item.
* @return {string} Unique component ID.
* @package
*/
getId(): string;
/**
* Gets the value associated with the menu item.
* @return {*} value Value associated with the menu item.
* @package
*/
getValue(): any;
/**
* Set menu item's rendering direction.
* @param {boolean} rtl True if RTL, false if LTR.
* @package
*/
setRightToLeft(rtl: boolean): void;
/**
* Set the menu item's accessibility role.
* @param {!Blockly.utils.aria.Role} roleName Role name.
* @package
*/
setRole(roleName: Blockly.utils.aria.Role): void;
/**
* Sets the menu item to be checkable or not. Set to true for menu items
* that represent checkable options.
* @param {boolean} checkable Whether the menu item is checkable.
* @package
*/
setCheckable(checkable: boolean): void;
/**
* Checks or unchecks the component.
* @param {boolean} checked Whether to check or uncheck the component.
* @package
*/
setChecked(checked: boolean): void;
/**
* Highlights or unhighlights the component.
* @param {boolean} highlight Whether to highlight or unhighlight the component.
* @package
*/
setHighlighted(highlight: boolean): void;
/**
* Returns true if the menu item is enabled, false otherwise.
* @return {boolean} Whether the menu item is enabled.
* @package
*/
isEnabled(): boolean;
/**
* Enables or disables the menu item.
* @param {boolean} enabled Whether to enable or disable the menu item.
* @package
*/
setEnabled(enabled: boolean): void;
/**
* Performs the appropriate action when the menu item is activated
* by the user.
* @package
*/
performAction(): void;
/**
* Set the handler that's called when the menu item is activated by the user.
* `obj` will be used as the 'this' object in the function when called.
* @param {function(!Blockly.MenuItem)} fn The handler.
* @param {!Object} obj Used as the 'this' object in fn when called.
* @package
*/
onAction(fn: { (_0: Blockly.MenuItem): any /*missing*/ }, obj: Object): void;
}
}
declare module Blockly {
class MetricsManager extends MetricsManager__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class MetricsManager__Class implements Blockly.IMetricsManager {
/**
* The manager for all workspace metrics calculations.
* @param {!Blockly.WorkspaceSvg} workspace The workspace to calculate metrics
* for.
* @implements {Blockly.IMetricsManager}
* @constructor
*/
constructor(workspace: Blockly.WorkspaceSvg);
/**
* The workspace to calculate metrics for.
* @type {!Blockly.WorkspaceSvg}
* @protected
*/
workspace_: Blockly.WorkspaceSvg;
/**
* Gets the dimensions of the given workspace component, in pixel coordinates.
* @param {?Blockly.IToolbox|?Blockly.IFlyout} elem The element to get the
* dimensions of, or null. It should be a toolbox or flyout, and should
* implement getWidth() and getHeight().
* @return {!Blockly.utils.Size} An object containing width and height
* attributes, which will both be zero if elem did not exist.
* @protected
*/
getDimensionsPx_(elem: Blockly.IToolbox|Blockly.IFlyout): Blockly.utils.Size;
/**
* Gets the width and the height of the flyout on the workspace in pixel
* coordinates. Returns 0 for the width and height if the workspace has a
* category toolbox instead of a simple toolbox.
* @param {boolean=} opt_own Whether to only return the workspace's own flyout.
* @return {!Blockly.MetricsManager.ToolboxMetrics} The width and height of the
* flyout.
* @public
*/
getFlyoutMetrics(opt_own?: boolean): Blockly.MetricsManager.ToolboxMetrics;
/**
* Gets the width, height and position of the toolbox on the workspace in pixel
* coordinates. Returns 0 for the width and height if the workspace has a simple
* toolbox instead of a category toolbox. To get the width and height of a
* simple toolbox @see {@link getFlyoutMetrics}.
* @return {!Blockly.MetricsManager.ToolboxMetrics} The object with the width,
* height and position of the toolbox.
* @public
*/
getToolboxMetrics(): Blockly.MetricsManager.ToolboxMetrics;
/**
* Gets the width and height of the workspace's parent SVG element in pixel
* coordinates. This area includes the toolbox and the visible workspace area.
* @return {!Blockly.utils.Size} The width and height of the workspace's parent
* SVG element.
* @public
*/
getSvgMetrics(): Blockly.utils.Size;
/**
* Gets the absolute left and absolute top in pixel coordinates.
* This is where the visible workspace starts in relation to the SVG container.
* @return {!Blockly.MetricsManager.AbsoluteMetrics} The absolute metrics for
* the workspace.
* @public
*/
getAbsoluteMetrics(): Blockly.MetricsManager.AbsoluteMetrics;
/**
* Gets the metrics for the visible workspace in either pixel or workspace
* coordinates. The visible workspace does not include the toolbox or flyout.
* @param {boolean=} opt_getWorkspaceCoordinates True to get the view metrics in
* workspace coordinates, false to get them in pixel coordinates.
* @return {!Blockly.MetricsManager.ContainerRegion} The width, height, top and
* left of the viewport in either workspace coordinates or pixel
* coordinates.
* @public
*/
getViewMetrics(opt_getWorkspaceCoordinates?: boolean): Blockly.MetricsManager.ContainerRegion;
/**
* Gets content metrics in either pixel or workspace coordinates.
* The content area is a rectangle around all the top bounded elements on the
* workspace (workspace comments and blocks).
* @param {boolean=} opt_getWorkspaceCoordinates True to get the content metrics
* in workspace coordinates, false to get them in pixel coordinates.
* @return {!Blockly.MetricsManager.ContainerRegion} The
* metrics for the content container.
* @public
*/
getContentMetrics(opt_getWorkspaceCoordinates?: boolean): Blockly.MetricsManager.ContainerRegion;
/**
* Returns whether the scroll area has fixed edges.
* @return {boolean} Whether the scroll area has fixed edges.
* @package
*/
hasFixedEdges(): boolean;
/**
* Computes the fixed edges of the scroll area.
* @param {!Blockly.MetricsManager.ContainerRegion=} opt_viewMetrics The view
* metrics if they have been previously computed. Passing in null may cause
* the view metrics to be computed again, if it is needed.
* @return {!Blockly.MetricsManager.FixedEdges} The fixed edges of the scroll
* area.
* @protected
*/
getComputedFixedEdges_(opt_viewMetrics?: Blockly.MetricsManager.ContainerRegion): Blockly.MetricsManager.FixedEdges;
/**
* Returns the content area with added padding.
* @param {!Blockly.MetricsManager.ContainerRegion} viewMetrics The view
* metrics.
* @param {!Blockly.MetricsManager.ContainerRegion} contentMetrics The content
* metrics.
* @return {{top: number, bottom: number, left: number, right: number}} The
* padded content area.
* @protected
*/
getPaddedContent_(viewMetrics: Blockly.MetricsManager.ContainerRegion, contentMetrics: Blockly.MetricsManager.ContainerRegion): { top: number; bottom: number; left: number; right: number };
/**
* Returns the metrics for the scroll area of the workspace.
* @param {boolean=} opt_getWorkspaceCoordinates True to get the scroll metrics
* in workspace coordinates, false to get them in pixel coordinates.
* @param {!Blockly.MetricsManager.ContainerRegion=} opt_viewMetrics The view
* metrics if they have been previously computed. Passing in null may cause
* the view metrics to be computed again, if it is needed.
* @param {!Blockly.MetricsManager.ContainerRegion=} opt_contentMetrics The
* content metrics if they have been previously computed. Passing in null
* may cause the content metrics to be computed again, if it is needed.
* @return {!Blockly.MetricsManager.ContainerRegion} The metrics for the scroll
* container.
*/
getScrollMetrics(opt_getWorkspaceCoordinates?: boolean, opt_viewMetrics?: Blockly.MetricsManager.ContainerRegion, opt_contentMetrics?: Blockly.MetricsManager.ContainerRegion): Blockly.MetricsManager.ContainerRegion;
/**
* Returns common metrics used by UI elements.
* @return {!Blockly.MetricsManager.UiMetrics} The UI metrics.
*/
getUiMetrics(): Blockly.MetricsManager.UiMetrics;
/**
* Returns an object with all the metrics required to size scrollbars for a
* top level workspace. The following properties are computed:
* Coordinate system: pixel coordinates, -left, -up, +right, +down
* .viewHeight: Height of the visible portion of the workspace.
* .viewWidth: Width of the visible portion of the workspace.
* .contentHeight: Height of the content.
* .contentWidth: Width of the content.
* .scrollHeight: Height of the scroll area.
* .scrollWidth: Width of the scroll area.
* .svgHeight: Height of the Blockly div (the view + the toolbox,
* simple or otherwise),
* .svgWidth: Width of the Blockly div (the view + the toolbox,
* simple or otherwise),
* .viewTop: Top-edge of the visible portion of the workspace, relative to
* the workspace origin.
* .viewLeft: Left-edge of the visible portion of the workspace, relative to
* the workspace origin.
* .contentTop: Top-edge of the content, relative to the workspace origin.
* .contentLeft: Left-edge of the content relative to the workspace origin.
* .scrollTop: Top-edge of the scroll area, relative to the workspace origin.
* .scrollLeft: Left-edge of the scroll area relative to the workspace origin.
* .absoluteTop: Top-edge of the visible portion of the workspace, relative
* to the blocklyDiv.
* .absoluteLeft: Left-edge of the visible portion of the workspace, relative
* to the blocklyDiv.
* .toolboxWidth: Width of the toolbox, if it exists. Otherwise zero.
* .toolboxHeight: Height of the toolbox, if it exists. Otherwise zero.
* .flyoutWidth: Width of the flyout if it is always open. Otherwise zero.
* .flyoutHeight: Height of the flyout if it is always open. Otherwise zero.
* .toolboxPosition: Top, bottom, left or right. Use TOOLBOX_AT constants to
* compare.
* @return {!Blockly.utils.Metrics} Contains size and position metrics of a top
* level workspace.
* @public
*/
getMetrics(): Blockly.utils.Metrics;
}
class FlyoutMetricsManager extends FlyoutMetricsManager__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class FlyoutMetricsManager__Class extends Blockly.MetricsManager__Class {
/**
* Calculates metrics for a flyout's workspace.
* The metrics are mainly used to size scrollbars for the flyout.
* @param {!Blockly.WorkspaceSvg} workspace The flyout's workspace.
* @param {!Blockly.IFlyout} flyout The flyout.
* @extends {Blockly.MetricsManager}
* @constructor
*/
constructor(workspace: Blockly.WorkspaceSvg, flyout: Blockly.IFlyout);
/**
* The flyout that owns the workspace to calculate metrics for.
* @type {!Blockly.IFlyout}
* @protected
*/
flyout_: Blockly.IFlyout;
}
}
declare module Blockly.MetricsManager {
/**
* Describes the width, height and location of the toolbox on the main
* workspace.
* @typedef {{
* width: number,
* height: number,
* position: !Blockly.utils.toolbox.Position
* }}
*/
interface ToolboxMetrics {
width: number;
height: number;
position: Blockly.utils.toolbox.Position
}
/**
* Describes where the viewport starts in relation to the workspace SVG.
* @typedef {{
* left: number,
* top: number
* }}
*/
interface AbsoluteMetrics {
left: number;
top: number
}
/**
* All the measurements needed to describe the size and location of a container.
* @typedef {{
* height: number,
* width: number,
* top: number,
* left: number
* }}
*/
interface ContainerRegion {
height: number;
width: number;
top: number;
left: number
}
/**
* Describes fixed edges of the workspace.
* @typedef {{
* top: (number|undefined),
* bottom: (number|undefined),
* left: (number|undefined),
* right: (number|undefined)
* }}
*/
interface FixedEdges {
top: number|any /*undefined*/;
bottom: number|any /*undefined*/;
left: number|any /*undefined*/;
right: number|any /*undefined*/
}
/**
* Common metrics used for UI elements.
* @typedef {{
* viewMetrics: !Blockly.MetricsManager.ContainerRegion,
* absoluteMetrics: !Blockly.MetricsManager.AbsoluteMetrics,
* toolboxMetrics: !Blockly.MetricsManager.ToolboxMetrics
* }}
*/
interface UiMetrics {
viewMetrics: Blockly.MetricsManager.ContainerRegion;
absoluteMetrics: Blockly.MetricsManager.AbsoluteMetrics;
toolboxMetrics: Blockly.MetricsManager.ToolboxMetrics
}
}
declare module Blockly {
class Mutator extends Mutator__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Mutator__Class extends Blockly.Icon__Class {
/**
* Class for a mutator dialog.
* @param {!Array<string>} quarkNames List of names of sub-blocks for flyout.
* @extends {Blockly.Icon}
* @constructor
*/
constructor(quarkNames: string[]);
/**
* Set the block this mutator is associated with.
* @param {!Blockly.BlockSvg} block The block associated with this mutator.
* @package
*/
setBlock(block: Blockly.BlockSvg): void;
/**
* Returns the workspace inside this mutator icon's bubble.
* @return {?Blockly.WorkspaceSvg} The workspace inside this mutator icon's
* bubble or null if the mutator isn't open.
* @package
*/
getWorkspace(): Blockly.WorkspaceSvg;
/**
* Draw the mutator icon.
* @param {!Element} group The icon group.
* @protected
*/
drawIcon_(group: Element): void;
/**
* Add or remove the UI indicating if this icon may be clicked or not.
*/
updateEditable(): void;
/**
* Show or hide the mutator bubble.
* @param {boolean} visible True if the bubble should be visible.
*/
setVisible(visible: boolean): void;
/**
* Dispose of this mutator.
*/
dispose(): void;
/**
* Update the styles on all blocks in the mutator.
* @public
*/
updateBlockStyle(): void;
}
}
declare module Blockly.Mutator {
/**
* Reconnect an block to a mutated input.
* @param {Blockly.Connection} connectionChild Connection on child block.
* @param {!Blockly.Block} block Parent block.
* @param {string} inputName Name of input on parent block.
* @return {boolean} True iff a reconnection was made, false otherwise.
*/
function reconnect(connectionChild: Blockly.Connection, block: Blockly.Block, inputName: string): boolean;
/**
* Get the parent workspace of a workspace that is inside a mutator, taking into
* account whether it is a flyout.
* @param {Blockly.Workspace} workspace The workspace that is inside a mutator.
* @return {?Blockly.Workspace} The mutator's parent workspace or null.
* @public
*/
function findParentWs(workspace: Blockly.Workspace): Blockly.Workspace;
}
declare module Blockly {
class Names extends Names__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Names__Class {
/**
* Class for a database of entity names (variables, procedures, etc).
* @param {string} reservedWords A comma-separated string of words that are
* illegal for use as names in a language (e.g. 'new,if,this,...').
* @param {string=} opt_variablePrefix Some languages need a '$' or a namespace
* before all variable names (but not procedure names).
* @constructor
*/
constructor(reservedWords: string, opt_variablePrefix?: string);
/**
* Empty the database and start from scratch. The reserved words are kept.
*/
reset(): void;
/**
* Set the variable map that maps from variable name to variable object.
* @param {!Blockly.VariableMap} map The map to track.
*/
setVariableMap(map: Blockly.VariableMap): void;
/**
* Generate names for user variables, but only ones that are being used.
* @param {!Blockly.Workspace} workspace Workspace to generate variables from.
*/
populateVariables(workspace: Blockly.Workspace): void;
/**
* Generate names for procedures.
* @param {!Blockly.Workspace} workspace Workspace to generate procedures from.
*/
populateProcedures(workspace: Blockly.Workspace): void;
/**
* Convert a Blockly entity name to a legal exportable entity name.
* @param {string} nameOrId The Blockly entity name (no constraints) or
* variable ID.
* @param {string} realm The realm of entity in Blockly
* ('VARIABLE', 'PROCEDURE', 'DEVELOPER_VARIABLE', etc...).
* @return {string} An entity name that is legal in the exported language.
*/
getName(nameOrId: string, realm: string): string;
/**
* Return a list of all known user-created names in a specified realm.
* @param {string} realm The realm of entity in Blockly
* ('VARIABLE', 'PROCEDURE', 'DEVELOPER_VARIABLE', etc...).
* @return {!Array<string>} A list of Blockly entity names (no constraints).
*/
getUserNames(realm: string): string[];
/**
* Convert a Blockly entity name to a legal exportable entity name.
* Ensure that this is a new name not overlapping any previously defined name.
* Also check against list of reserved words for the current language and
* ensure name doesn't collide.
* @param {string} name The Blockly entity name (no constraints).
* @param {string} realm The realm of entity in Blockly
* ('VARIABLE', 'PROCEDURE', 'DEVELOPER_VARIABLE', etc...).
* @return {string} An entity name that is legal in the exported language.
*/
getDistinctName(name: string, realm: string): string;
}
}
declare module Blockly.Names {
/**
* Constant to separate developer variable names from user-defined variable
* names when running generators.
* A developer variable will be declared as a global in the generated code, but
* will never be shown to the user in the workspace or stored in the variable
* map.
*/
var DEVELOPER_VARIABLE_TYPE: any /*missing*/;
/**
* Do the given two entity names refer to the same entity?
* Blockly names are case-insensitive.
* @param {string} name1 First name.
* @param {string} name2 Second name.
* @return {boolean} True if names are the same.
*/
function equals(name1: string, name2: string): boolean;
}
declare module Blockly {
class Options extends Options__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Options__Class {
/**
* Parse the user-specified options, using reasonable defaults where behaviour
* is unspecified.
* @param {!Blockly.BlocklyOptions} options Dictionary of options.
* Specification: https://developers.google.com/blockly/guides/get-started/web#configuration
* @constructor
*/
constructor(options: Blockly.BlocklyOptions);
/** @type {boolean} */
RTL: boolean;
/** @type {boolean} */
oneBasedIndex: boolean;
/** @type {boolean} */
collapse: boolean;
/** @type {boolean} */
comments: boolean;
/** @type {boolean} */
disable: boolean;
/** @type {boolean} */
readOnly: boolean;
/** @type {number} */
maxBlocks: number;
/** @type {?Object<string, number>} */
maxInstances: { [key: string]: number };
/** @type {string} */
pathToMedia: string;
/** @type {boolean} */
hasCategories: boolean;
/** @type {!Blockly.Options.MoveOptions} */
moveOptions: Blockly.Options.MoveOptions;
/** @deprecated January 2019 */
hasScrollbars: any /*missing*/;
/** @type {boolean} */
hasTrashcan: boolean;
/** @type {number} */
maxTrashcanContents: number;
/** @type {boolean} */
hasSounds: boolean;
/** @type {boolean} */
hasCss: boolean;
/** @type {boolean} */
horizontalLayout: boolean;
/** @type {?Blockly.utils.toolbox.ToolboxInfo} */
languageTree: Blockly.utils.toolbox.ToolboxInfo;
/** @type {!Blockly.Options.GridOptions} */
gridOptions: Blockly.Options.GridOptions;
/** @type {!Blockly.Options.ZoomOptions} */
zoomOptions: Blockly.Options.ZoomOptions;
/** @type {!Blockly.utils.toolbox.Position} */
toolboxPosition: Blockly.utils.toolbox.Position;
/** @type {!Blockly.Theme} */
theme: Blockly.Theme;
/** @type {string} */
renderer: string;
/** @type {?Object} */
rendererOverrides: Object;
/**
* The SVG element for the grid pattern.
* Created during injection.
* @type {?SVGElement}
*/
gridPattern: SVGElement;
/**
* The parent of the current workspace, or null if there is no parent
* workspace. We can assert that this is of type WorkspaceSvg as opposed to
* Workspace as this is only used in a rendered workspace.
* @type {Blockly.WorkspaceSvg}
*/
parentWorkspace: Blockly.WorkspaceSvg;
/**
* Map of plugin type to name of registered plugin or plugin class.
* @type {!Object<string, (function(new:?, ...?)|string)>}
*/
plugins: any /*missing*/;
/**
* If set, sets the translation of the workspace to match the scrollbars.
* @param {!{x:number,y:number}} xyRatio Contains an x and/or y property which
* is a float between 0 and 1 specifying the degree of scrolling.
* @return {void}
*/
setMetrics(xyRatio: { x: number; y: number }): void;
/**
* Return an object with the metrics required to size the workspace.
* @return {!Blockly.utils.Metrics} Contains size and position metrics.
*/
getMetrics(): Blockly.utils.Metrics;
}
interface BlocklyOptions {
}
}
declare module Blockly.Options {
/**
* Grid Options.
* @typedef {{
* colour: string,
* length: number,
* snap: boolean,
* spacing: number
* }}
*/
interface GridOptions {
colour: string;
length: number;
snap: boolean;
spacing: number
}
/**
* Move Options.
* @typedef {{
* drag: boolean,
* scrollbars: (boolean | !Blockly.Options.ScrollbarOptions),
* wheel: boolean
* }}
*/
interface MoveOptions {
drag: boolean;
scrollbars: boolean|Blockly.Options.ScrollbarOptions;
wheel: boolean
}
/**
* Scrollbar Options.
* @typedef {{
* horizontal: boolean,
* vertical: boolean
* }}
*/
interface ScrollbarOptions {
horizontal: boolean;
vertical: boolean
}
/**
* Zoom Options.
* @typedef {{
* controls: boolean,
* maxScale: number,
* minScale: number,
* pinch: boolean,
* scaleSpeed: number,
* startScale: number,
* wheel: boolean
* }}
*/
interface ZoomOptions {
controls: boolean;
maxScale: number;
minScale: number;
pinch: boolean;
scaleSpeed: number;
startScale: number;
wheel: boolean
}
/**
* Parse the provided toolbox tree into a consistent DOM format.
* @param {?Node|?string} toolboxDef DOM tree of blocks, or text representation
* of same.
* @return {?Node} DOM tree of blocks, or null.
* @deprecated Use Blockly.utils.toolbox.parseToolboxTree. (2020 September 28)
*/
function parseToolboxTree(toolboxDef: Node|string): Node;
}
declare module Blockly.uiPosition {
/**
* Enum for vertical positioning.
* @enum {number}
* @package
*/
enum verticalPosition { TOP, BOTTOM }
/**
* Enum for horizontal positioning.
* @enum {number}
* @package
*/
enum horizontalPosition { LEFT, RIGHT }
/**
* An object defining a horizontal and vertical positioning.
* @typedef {{
* horizontal: !Blockly.uiPosition.horizontalPosition,
* vertical: !Blockly.uiPosition.verticalPosition
* }}
* @package
*/
interface Position {
horizontal: Blockly.uiPosition.horizontalPosition;
vertical: Blockly.uiPosition.verticalPosition
}
/**
* Enum for bump rules to use for dealing with collisions.
* @enum {number}
* @package
*/
enum bumpDirection { UP, DOWN }
/**
* Returns a rectangle representing reasonable position for where to place a UI
* element of the specified size given the restraints and locations of the
* scrollbars. This method does not take into account any already placed UI
* elements.
* @param {!Blockly.uiPosition.Position} position The starting
* horizontal and vertical position.
* @param {!Blockly.utils.Size} size the size of the UI element to get a start
* position for.
* @param {number} horizontalPadding The horizontal padding to use.
* @param {number} verticalPadding The vertical padding to use.
* @param {!Blockly.MetricsManager.UiMetrics} metrics The workspace UI metrics.
* @param {!Blockly.WorkspaceSvg} workspace The workspace.
* @return {!Blockly.utils.Rect} The suggested start position.
* @package
*/
function getStartPositionRect(position: Blockly.uiPosition.Position, size: Blockly.utils.Size, horizontalPadding: number, verticalPadding: number, metrics: Blockly.MetricsManager.UiMetrics, workspace: Blockly.WorkspaceSvg): Blockly.utils.Rect;
/**
* Returns a corner position that is on the opposite side of the workspace from
* the toolbox.
* If in horizontal orientation, defaults to the bottom corner. If in vertical
* orientation, defaults to the right corner.
* @param {!Blockly.WorkspaceSvg} workspace The workspace.
* @param {!Blockly.MetricsManager.UiMetrics} metrics The workspace metrics.
* @return {!Blockly.uiPosition.Position} The suggested corner position.
* @package
*/
function getCornerOppositeToolbox(workspace: Blockly.WorkspaceSvg, metrics: Blockly.MetricsManager.UiMetrics): Blockly.uiPosition.Position;
/**
* Returns a position Rect based on a starting position that is bumped
* so that it doesn't intersect with any of the provided savedPositions. This
* method does not check that the bumped position is still within bounds.
* @param {!Blockly.utils.Rect} startRect The starting position to use.
* @param {number} margin The margin to use between elements when bumping.
* @param {!Blockly.uiPosition.bumpDirection} bumpDirection The direction
* to bump if there is a collision with an existing UI element.
* @param {!Array<!Blockly.utils.Rect>} savedPositions List of rectangles that
* represent the positions of UI elements already placed.
* @return {!Blockly.utils.Rect} The suggested position rectangle.
* @package
*/
function bumpPositionRect(startRect: Blockly.utils.Rect, margin: number, bumpDirection: Blockly.uiPosition.bumpDirection, savedPositions: Blockly.utils.Rect[]): Blockly.utils.Rect;
}
declare module Blockly.Procedures {
/**
* Constant to separate procedure names from variables and generated functions
* when running generators.
* @deprecated Use Blockly.PROCEDURE_CATEGORY_NAME
*/
var NAME_TYPE: any /*missing*/;
/**
* The default argument for a procedures_mutatorarg block.
* @type {string}
*/
var DEFAULT_ARG: string;
/**
* Procedure block type.
* @typedef {{
* getProcedureCall: function():string,
* renameProcedure: function(string,string),
* getProcedureDef: function():!Array
* }}
*/
interface ProcedureBlock {
getProcedureCall: { (): string };
renameProcedure: { (_0: string, _1: string): any /*missing*/ };
getProcedureDef: { (): any[] }
}
/**
* Find all user-created procedure definitions in a workspace.
* @param {!Blockly.Workspace} root Root workspace.
* @return {!Array<!Array<!Array>>} Pair of arrays, the
* first contains procedures without return variables, the second with.
* Each procedure is defined by a three-element list of name, parameter
* list, and return value boolean.
*/
function allProcedures(root: Blockly.Workspace): any[][][];
/**
* Ensure two identically-named procedures don't exist.
* Take the proposed procedure name, and return a legal name i.e. one that
* is not empty and doesn't collide with other procedures.
* @param {string} name Proposed procedure name.
* @param {!Blockly.Block} block Block to disambiguate.
* @return {string} Non-colliding name.
*/
function findLegalName(name: string, block: Blockly.Block): string;
/**
* Return if the given name is already a procedure name.
* @param {string} name The questionable name.
* @param {!Blockly.Workspace} workspace The workspace to scan for collisions.
* @param {Blockly.Block=} opt_exclude Optional block to exclude from
* comparisons (one doesn't want to collide with oneself).
* @return {boolean} True if the name is used, otherwise return false.
*/
function isNameUsed(name: string, workspace: Blockly.Workspace, opt_exclude?: Blockly.Block): boolean;
/**
* Rename a procedure. Called by the editable field.
* @param {string} name The proposed new name.
* @return {string} The accepted name.
* @this {Blockly.Field}
*/
function rename(name: string): string;
/**
* Construct the blocks required by the flyout for the procedure category.
* @param {!Blockly.Workspace} workspace The workspace containing procedures.
* @return {!Array<!Element>} Array of XML block elements.
*/
function flyoutCategory(workspace: Blockly.Workspace): Element[];
/**
* Listens for when a procedure mutator is opened. Then it triggers a flyout
* update and adds a mutator change listener to the mutator workspace.
* @param {!Blockly.Events.Abstract} e The event that triggered this listener.
* @package
*/
function mutatorOpenListener(e: Blockly.Events.Abstract): void;
/**
* Find all the callers of a named procedure.
* @param {string} name Name of procedure.
* @param {!Blockly.Workspace} workspace The workspace to find callers in.
* @return {!Array<!Blockly.Block>} Array of caller blocks.
*/
function getCallers(name: string, workspace: Blockly.Workspace): Blockly.Block[];
/**
* When a procedure definition changes its parameters, find and edit all its
* callers.
* @param {!Blockly.Block} defBlock Procedure definition block.
*/
function mutateCallers(defBlock: Blockly.Block): void;
/**
* Find the definition block for the named procedure.
* @param {string} name Name of procedure.
* @param {!Blockly.Workspace} workspace The workspace to search.
* @return {?Blockly.Block} The procedure definition block, or null not found.
*/
function getDefinition(name: string, workspace: Blockly.Workspace): Blockly.Block;
}
declare module Blockly.registry {
class Type<T> extends Type__Class<T> { }
/** Fake class which should be extended to avoid inheriting static properties */
class Type__Class<T> {
/**
* A name with the type of the element stored in the generic.
* @param {string} name The name of the registry type.
* @constructor
* @template T
*/
constructor(name: string);
}
/**
* A map of maps. With the keys being the type and name of the class we are
* registering and the value being the constructor function.
* e.g. {'field': {'field_angle': Blockly.FieldAngle}}
*
* @type {Object<string, Object<string, function(new:?)>>}
*/
var typeMap_: any /*missing*/;
/**
* The string used to register the default class for a type of plugin.
* @type {string}
*/
var DEFAULT: string;
/**
* Registers a class based on a type and name.
* @param {string|!Blockly.registry.Type<T>} type The type of the plugin.
* (e.g. Field, Renderer)
* @param {string} name The plugin's name. (Ex. field_angle, geras)
* @param {?function(new:T, ...?)|Object} registryItem The class or object to
* register.
* @param {boolean=} opt_allowOverrides True to prevent an error when overriding
* an already registered item.
* @throws {Error} if the type or name is empty, a name with the given type has
* already been registered, or if the given class or object is not valid for
* it's type.
* @template T
*/
function register<T>(type: string|Blockly.registry.Type<T>, name: string, registryItem: { (_0: any[]): any /*missing*/ }|Object, opt_allowOverrides?: boolean): void;
/**
* Unregisters the registry item with the given type and name.
* @param {string|!Blockly.registry.Type<T>} type The type of the plugin.
* (e.g. Field, Renderer)
* @param {string} name The plugin's name. (Ex. field_angle, geras)
* @template T
*/
function unregister<T>(type: string|Blockly.registry.Type<T>, name: string): void;
/**
* Gets the registry item for the given name and type. This can be either a
* class or an object.
* @param {string|!Blockly.registry.Type<T>} type The type of the plugin.
* (e.g. Field, Renderer)
* @param {string} name The plugin's name. (Ex. field_angle, geras)
* @param {boolean=} opt_throwIfMissing Whether or not to throw an error if we
* are unable to find the plugin.
* @return {?function(new:T, ...?)|Object} The class or object with the given
* name and type or null if none exists.
* @template T
*/
function getItem_<T>(type: string|Blockly.registry.Type<T>, name: string, opt_throwIfMissing?: boolean): { (_0: any[]): any /*missing*/ }|Object;
/**
* Returns whether or not the registry contains an item with the given type and
* name.
* @param {string|!Blockly.registry.Type<T>} type The type of the plugin.
* (e.g. Field, Renderer)
* @param {string} name The plugin's name. (Ex. field_angle, geras)
* @return {boolean} True if the registry has an item with the given type and
* name, false otherwise.
* @template T
*/
function hasItem<T>(type: string|Blockly.registry.Type<T>, name: string): boolean;
/**
* Gets the class for the given name and type.
* @param {string|!Blockly.registry.Type<T>} type The type of the plugin.
* (e.g. Field, Renderer)
* @param {string} name The plugin's name. (Ex. field_angle, geras)
* @param {boolean=} opt_throwIfMissing Whether or not to throw an error if we
* are unable to find the plugin.
* @return {?function(new:T, ...?)} The class with the given name and type or
* null if none exists.
* @template T
*/
function getClass<T>(type: string|Blockly.registry.Type<T>, name: string, opt_throwIfMissing?: boolean): { (_0: any[]): any /*missing*/ };
/**
* Gets the object for the given name and type.
* @param {string|!Blockly.registry.Type<T>} type The type of the plugin.
* (e.g. Category)
* @param {string} name The plugin's name. (Ex. logic_category)
* @param {boolean=} opt_throwIfMissing Whether or not to throw an error if we
* are unable to find the object.
* @return {?T} The object with the given name and type or null if none exists.
* @template T
*/
function getObject<T>(type: string|Blockly.registry.Type<T>, name: string, opt_throwIfMissing?: boolean): T;
/**
* Gets the class from Blockly options for the given type.
* This is used for plugins that override a built in feature. (e.g. Toolbox)
* @param {!Blockly.registry.Type<T>} type The type of the plugin.
* @param {!Blockly.Options} options The option object to check for the given
* plugin.
* @param {boolean=} opt_throwIfMissing Whether or not to throw an error if we
* are unable to find the plugin.
* @return {?function(new:T, ...?)} The class for the plugin.
* @template T
*/
function getClassFromOptions<T>(type: Blockly.registry.Type<T>, options: Blockly.Options, opt_throwIfMissing?: boolean): { (_0: any[]): any /*missing*/ };
}
declare module Blockly.registry.Type {
/** @type {!Blockly.registry.Type<Blockly.IConnectionChecker>} */
var CONNECTION_CHECKER: Blockly.registry.Type<Blockly.IConnectionChecker>;
/** @type {!Blockly.registry.Type<Blockly.Cursor>} */
var CURSOR: Blockly.registry.Type<Blockly.Cursor>;
/** @type {!Blockly.registry.Type<Blockly.Events.Abstract>} */
var EVENT: Blockly.registry.Type<Blockly.Events.Abstract>;
/** @type {!Blockly.registry.Type<Blockly.Field>} */
var FIELD: Blockly.registry.Type<Blockly.Field>;
/** @type {!Blockly.registry.Type<Blockly.blockRendering.Renderer>} */
var RENDERER: Blockly.registry.Type<Blockly.blockRendering.Renderer>;
/** @type {!Blockly.registry.Type<Blockly.IToolbox>} */
var TOOLBOX: Blockly.registry.Type<Blockly.IToolbox>;
/** @type {!Blockly.registry.Type<Blockly.Theme>} */
var THEME: Blockly.registry.Type<Blockly.Theme>;
/** @type {!Blockly.registry.Type<Blockly.ToolboxItem>} */
var TOOLBOX_ITEM: Blockly.registry.Type<Blockly.ToolboxItem>;
/** @type {!Blockly.registry.Type<Blockly.IFlyout>} */
var FLYOUTS_VERTICAL_TOOLBOX: Blockly.registry.Type<Blockly.IFlyout>;
/** @type {!Blockly.registry.Type<Blockly.IFlyout>} */
var FLYOUTS_HORIZONTAL_TOOLBOX: Blockly.registry.Type<Blockly.IFlyout>;
/** @type {!Blockly.registry.Type<Blockly.IMetricsManager>} */
var METRICS_MANAGER: Blockly.registry.Type<Blockly.IMetricsManager>;
/** @type {!Blockly.registry.Type<Blockly.IBlockDragger>} */
var BLOCK_DRAGGER: Blockly.registry.Type<Blockly.IBlockDragger>;
}
declare module Blockly {
class RenderedConnection extends RenderedConnection__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class RenderedConnection__Class extends Blockly.Connection__Class {
/**
* Class for a connection between blocks that may be rendered on screen.
* @param {!Blockly.BlockSvg} source The block establishing this connection.
* @param {number} type The type of the connection.
* @extends {Blockly.Connection}
* @constructor
*/
constructor(source: Blockly.BlockSvg, type: number);
/**
* Connection this connection connects to. Null if not connected.
* @type {Blockly.RenderedConnection}
*/
targetConnection: Blockly.RenderedConnection;
/**
* Returns the distance between this connection and another connection in
* workspace units.
* @param {!Blockly.Connection} otherConnection The other connection to measure
* the distance to.
* @return {number} The distance between connections, in workspace units.
*/
distanceFrom(otherConnection: Blockly.Connection): number;
/**
* Move the block(s) belonging to the connection to a point where they don't
* visually interfere with the specified connection.
* @param {!Blockly.Connection} staticConnection The connection to move away
* from.
* @package
*/
bumpAwayFrom(staticConnection: Blockly.Connection): void;
/**
* Change the connection's coordinates.
* @param {number} x New absolute x coordinate, in workspace coordinates.
* @param {number} y New absolute y coordinate, in workspace coordinates.
*/
moveTo(x: number, y: number): void;
/**
* Change the connection's coordinates.
* @param {number} dx Change to x coordinate, in workspace units.
* @param {number} dy Change to y coordinate, in workspace units.
*/
moveBy(dx: number, dy: number): void;
/**
* Move this connection to the location given by its offset within the block and
* the location of the block's top left corner.
* @param {!Blockly.utils.Coordinate} blockTL The location of the top left
* corner of the block, in workspace coordinates.
*/
moveToOffset(blockTL: Blockly.utils.Coordinate): void;
/**
* Set the offset of this connection relative to the top left of its block.
* @param {number} x The new relative x, in workspace units.
* @param {number} y The new relative y, in workspace units.
*/
setOffsetInBlock(x: number, y: number): void;
/**
* Get the offset of this connection relative to the top left of its block.
* @return {!Blockly.utils.Coordinate} The offset of the connection.
* @package
*/
getOffsetInBlock(): Blockly.utils.Coordinate;
/**
* Move the blocks on either side of this connection right next to each other.
* @package
*/
tighten(): void;
/**
* Find the closest compatible connection to this connection.
* All parameters are in workspace units.
* @param {number} maxLimit The maximum radius to another connection.
* @param {!Blockly.utils.Coordinate} dxy Offset between this connection's location
* in the database and the current location (as a result of dragging).
* @return {!{connection: ?Blockly.Connection, radius: number}} Contains two
* properties: 'connection' which is either another connection or null,
* and 'radius' which is the distance.
*/
closest(maxLimit: number, dxy: Blockly.utils.Coordinate): { connection: Blockly.Connection; radius: number };
/**
* Add highlighting around this connection.
*/
highlight(): void;
/**
* Remove the highlighting around this connection.
*/
unhighlight(): void;
/**
* Set whether this connections is tracked in the database or not.
* @param {boolean} doTracking If true, start tracking. If false, stop tracking.
* @package
*/
setTracking(doTracking: boolean): void;
/**
* Stop tracking this connection, as well as all down-stream connections on
* any block attached to this connection. This happens when a block is
* collapsed.
*
* Also closes down-stream icons/bubbles.
* @package
*/
stopTrackingAll(): void;
/**
* Start tracking this connection, as well as all down-stream connections on
* any block attached to this connection. This happens when a block is expanded.
* @return {!Array<!Blockly.Block>} List of blocks to render.
*/
startTrackingAll(): Blockly.Block[];
/**
* Check if the two connections can be dragged to connect to each other.
* @param {!Blockly.Connection} candidate A nearby connection to check.
* @param {number=} maxRadius The maximum radius allowed for connections, in
* workspace units.
* @return {boolean} True if the connection is allowed, false otherwise.
* @deprecated July 2020
*/
isConnectionAllowed(candidate: Blockly.Connection, maxRadius?: number): boolean;
/**
* Behavior after a connection attempt fails.
* Bumps this connection away from the other connection. Called when an
* attempted connection fails.
* @param {!Blockly.Connection} otherConnection Connection that this connection
* failed to connect to.
* @package
*/
onFailedConnect(otherConnection: Blockly.Connection): void;
/**
* Find all nearby compatible connections to this connection.
* Type checking does not apply, since this function is used for bumping.
* @param {number} maxLimit The maximum radius to another connection, in
* workspace units.
* @return {!Array<!Blockly.Connection>} List of connections.
* @package
*/
neighbours(maxLimit: number): Blockly.Connection[];
/**
* Connect two connections together. This is the connection on the superior
* block. Rerender blocks as needed.
* @param {!Blockly.Connection} childConnection Connection on inferior block.
* @protected
*/
connect_(childConnection: Blockly.Connection): void;
/**
* Function to be called when this connection's compatible types have changed.
* @protected
*/
onCheckChanged_(): void;
}
}
declare module Blockly.RenderedConnection {
/**
* Enum for different kinds of tracked states.
*
* WILL_TRACK means that this connection will add itself to
* the db on the next moveTo call it receives.
*
* UNTRACKED means that this connection will not add
* itself to the database until setTracking(true) is explicitly called.
*
* TRACKED means that this connection is currently being tracked.
* @enum {number}
*/
enum TrackedState { WILL_TRACK, UNTRACKED, TRACKED }
}
declare module Blockly {
class ScrollbarPair extends ScrollbarPair__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class ScrollbarPair__Class {
/**
* Class for a pair of scrollbars. Horizontal and vertical.
* @param {!Blockly.WorkspaceSvg} workspace Workspace to bind the scrollbars to.
* @param {boolean=} 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.
* @constructor
*/
constructor(workspace: Blockly.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 {boolean} True if horizontal scroll is enabled.
*/
canScrollHorizontally(): boolean;
/**
* Returns whether scrolling vertically is enabled.
* @return {boolean} 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 {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
*/
setOrigin(x: number, y: number): void;
/**
* 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.
* 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 {number} 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 {number} y Vertical scroll value.
*/
setY(y: number): void;
/**
* Set whether this scrollbar's container is visible.
* @param {boolean} 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 {boolean} 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 {!Blockly.utils.Metrics} hostMetrics A data structure describing all
* the required dimensions, possibly fetched from the host object.
*/
resizeContent(hostMetrics: Blockly.utils.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 {!Blockly.utils.Metrics} hostMetrics A data structure describing all
* the required dimensions, possibly fetched from the host object.
*/
resizeView(hostMetrics: Blockly.utils.Metrics): void;
}
class Scrollbar extends Scrollbar__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Scrollbar__Class {
/**
* Class for a pure SVG scrollbar.
* This technique offers a scrollbar that is guaranteed to work, but may not
* look or behave like the system's scrollbars.
* @param {!Blockly.WorkspaceSvg} workspace Workspace to bind the scrollbar to.
* @param {boolean} horizontal True if horizontal, false if vertical.
* @param {boolean=} opt_pair True if scrollbar is part of a horiz/vert pair.
* @param {string=} opt_class A class to be applied to this scrollbar.
* @param {number=} opt_margin The margin to apply to this scrollbar.
* @constructor
*/
constructor(workspace: Blockly.WorkspaceSvg, horizontal: boolean, opt_pair?: boolean, opt_class?: string, opt_margin?: number);
/**
* The ratio of handle position offset to workspace content displacement.
* @type {?number}
* @package
*/
ratio: number;
/**
* The upper left corner of the scrollbar's SVG group in CSS pixels relative
* to the scrollbar's origin. This is usually relative to the injection div
* origin.
* @type {Blockly.utils.Coordinate}
* @package
*/
position: Blockly.utils.Coordinate;
/**
* Dispose of this scrollbar.
* Unlink from all DOM elements to prevent memory leaks.
* @suppress {checkTypes}
*/
dispose(): void;
/**
* Set the offset of the scrollbar's handle from the scrollbar's position, and
* change the SVG attribute accordingly.
* @param {number} newPosition The new scrollbar handle offset in CSS pixels.
*/
setHandlePosition(newPosition: number): void;
/**
* Set the position of the scrollbar's SVG group in CSS pixels relative to the
* scrollbar's origin. This sets the scrollbar's location within the workspace.
* @param {number} x The new x coordinate.
* @param {number} y The new y coordinate.
* @package
*/
setPosition(x: number, y: number): void;
/**
* Recalculate the scrollbar's location and its length.
* @param {Blockly.utils.Metrics=} opt_metrics A data structure of from the
* describing all the required dimensions. If not provided, it will be
* fetched from the host object.
*/
resize(opt_metrics?: Blockly.utils.Metrics): void;
/**
* Recalculate a horizontal scrollbar's location on the screen and path length.
* This should be called when the layout or size of the window has changed.
* @param {!Blockly.utils.Metrics} hostMetrics A data structure describing all
* the required dimensions, possibly fetched from the host object.
*/
resizeViewHorizontal(hostMetrics: Blockly.utils.Metrics): void;
/**
* Recalculate a horizontal scrollbar's location within its path and length.
* This should be called when the contents of the workspace have changed.
* @param {!Blockly.utils.Metrics} hostMetrics A data structure describing all
* the required dimensions, possibly fetched from the host object.
*/
resizeContentHorizontal(hostMetrics: Blockly.utils.Metrics): void;
/**
* Recalculate a vertical scrollbar's location on the screen and path length.
* This should be called when the layout or size of the window has changed.
* @param {!Blockly.utils.Metrics} hostMetrics A data structure describing all
* the required dimensions, possibly fetched from the host object.
*/
resizeViewVertical(hostMetrics: Blockly.utils.Metrics): void;
/**
* Recalculate a vertical scrollbar's location within its path and length.
* This should be called when the contents of the workspace have changed.
* @param {!Blockly.utils.Metrics} hostMetrics A data structure describing all
* the required dimensions, possibly fetched from the host object.
*/
resizeContentVertical(hostMetrics: Blockly.utils.Metrics): void;
/**
* Is the scrollbar visible. Non-paired scrollbars disappear when they aren't
* needed.
* @return {boolean} True if visible.
*/
isVisible(): boolean;
/**
* Set whether the scrollbar's container is visible and update
* display accordingly if visibility has changed.
* @param {boolean} visible Whether the container is visible
*/
setContainerVisible(visible: boolean): void;
/**
* Set whether the scrollbar is visible.
* Only applies to non-paired scrollbars.
* @param {boolean} visible True if visible.
*/
setVisible(visible: boolean): void;
/**
* Update visibility of scrollbar based on whether it thinks it should
* be visible and whether its containing workspace is visible.
* We cannot rely on the containing workspace being hidden to hide us
* because it is not necessarily our parent in the DOM.
*/
updateDisplay_(): void;
/**
* Helper to calculate the ratio of handle position to scrollbar view size.
* @return {number} Ratio.
* @protected
*/
getRatio_(): number;
/**
* Set the scrollbar handle's position.
* @param {number} value The content displacement, relative to the view in
* pixels.
* @param {boolean=} updateMetrics Whether to update metrics on this set call.
* Defaults to true.
*/
set(value: number, updateMetrics?: boolean): void;
/**
* 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 {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.
*/
setOrigin(x: number, y: number): void;
}
}
declare module Blockly.Scrollbar {
/**
* Width of vertical scrollbar or height of horizontal scrollbar in CSS pixels.
* Scrollbars should be larger on touch devices.
*/
var scrollbarThickness: any /*missing*/;
/**
* Default margin around the scrollbar (between the scrollbar and the edge of
* the viewport in pixels).
* @type {number}
* @const
* @package
*/
var DEFAULT_SCROLLBAR_MARGIN: number;
}
declare module Blockly.ShortcutItems {
/**
* Object holding the names of the default shortcut items.
* @enum {string}
*/
enum names { ESCAPE, DELETE, COPY, CUT, PASTE, UNDO, REDO }
/** Keyboard shortcut to hide chaff on escape. */
function registerEscape(): void;
/** Keyboard shortcut to delete a block on delete or backspace */
function registerDelete(): void;
/** Keyboard shortcut to copy a block on ctrl+c, cmd+c, or alt+c. */
function registerCopy(): void;
/** Keyboard shortcut to copy and delete a block on ctrl+x, cmd+x, or alt+x. */
function registerCut(): void;
/** Keyboard shortcut to paste a block on ctrl+v, cmd+v, or alt+v. */
function registerPaste(): void;
/** Keyboard shortcut to undo the previous action on ctrl+z, cmd+z, or alt+z. */
function registerUndo(): void;
/** Keyboard shortcut to redo the previous action on ctrl+shift+z, cmd+shift+z, or alt+shift+z. */
function registerRedo(): void;
/**
* Registers all default keyboard shortcut item. This should be called once per instance of
* KeyboardShortcutRegistry.
* @package
*/
function registerDefaultShortcuts(): void;
}
declare module Blockly {
class ShortcutRegistry extends ShortcutRegistry__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class ShortcutRegistry__Class {
/**
* Class for the registry of keyboard shortcuts. This is intended to be a
* singleton. You should not create a new instance, and only access this class
* from Blockly.ShortcutRegistry.registry.
* @constructor
*/
constructor();
/**
* Registers a keyboard shortcut.
* @param {!Blockly.ShortcutRegistry.KeyboardShortcut} shortcut The
* shortcut for this key code.
* @param {boolean=} opt_allowOverrides True to prevent a warning when
* overriding an already registered item.
* @throws {Error} if a shortcut with the same name already exists.
* @public
*/
register(shortcut: Blockly.ShortcutRegistry.KeyboardShortcut, opt_allowOverrides?: boolean): void;
/**
* Unregisters a keyboard shortcut registered with the given key code. This will
* also remove any key mappings that reference this shortcut.
* @param {string} shortcutName The name of the shortcut to unregister.
* @return {boolean} True if an item was unregistered, false otherwise.
* @public
*/
unregister(shortcutName: string): boolean;
/**
* Adds a mapping between a keycode and a keyboard shortcut.
* @param {string|Blockly.utils.KeyCodes} keyCode The key code for the keyboard
* shortcut. If registering a key code with a modifier (ex: ctrl+c) use
* Blockly.ShortcutRegistry.registry.createSerializedKey;
* @param {string} shortcutName The name of the shortcut to execute when the
* given keycode is pressed.
* @param {boolean=} opt_allowCollision True to prevent an error when adding a
* shortcut to a key that is already mapped to a shortcut.
* @throws {Error} if the given key code is already mapped to a shortcut.
* @public
*/
addKeyMapping(keyCode: string|Blockly.utils.KeyCodes, shortcutName: string, opt_allowCollision?: boolean): void;
/**
* Removes a mapping between a keycode and a keyboard shortcut.
* @param {string} keyCode The key code for the keyboard shortcut. If
* registering a key code with a modifier (ex: ctrl+c) use
* Blockly.ShortcutRegistry.registry.createSerializedKey;
* @param {string} shortcutName The name of the shortcut to execute when the
* given keycode is pressed.
* @param {boolean=} opt_quiet True to not console warn when there is no
* shortcut to remove.
* @return {boolean} True if a key mapping was removed, false otherwise.
* @public
*/
removeKeyMapping(keyCode: string, shortcutName: string, opt_quiet?: boolean): boolean;
/**
* Removes all the key mappings for a shortcut with the given name.
* Useful when changing the default key mappings and the key codes registered to the shortcut are
* unknown.
* @param {string} shortcutName The name of the shortcut to remove from the key map.
* @public
*/
removeAllKeyMappings(shortcutName: string): void;
/**
* Sets the key map. Setting the key map will override any default key mappings.
* @param {!Object<string, !Array<string>>} keyMap The object with key code to
* shortcut names.
* @public
*/
setKeyMap(keyMap: { [key: string]: string[] }): void;
/**
* Gets the current key map.
* @return {!Object<string,!Array<!Blockly.ShortcutRegistry.KeyboardShortcut>>}
* The object holding key codes to Blockly.ShortcutRegistry.KeyboardShortcut.
* @public
*/
getKeyMap(): { [key: string]: Blockly.ShortcutRegistry.KeyboardShortcut[] };
/**
* Gets the registry of keyboard shortcuts.
* @return {!Object<string, !Blockly.ShortcutRegistry.KeyboardShortcut>}
* The registry of keyboard shortcuts.
* @public
*/
getRegistry(): { [key: string]: Blockly.ShortcutRegistry.KeyboardShortcut };
/**
* Handles key down events.
* @param {!Blockly.Workspace} workspace The main workspace where the event was
* captured.
* @param {!Event} e The key down event.
* @return {boolean} True if the event was handled, false otherwise.
* @public
*/
onKeyDown(workspace: Blockly.Workspace, e: Event): boolean;
/**
* Gets the shortcuts registered to the given key code.
* @param {string} keyCode The serialized key code.
* @return {!Array<string>|undefined} The list of shortcuts to call when the
* given keyCode is used. Undefined if no shortcuts exist.
* @public
*/
getShortcutNamesByKeyCode(keyCode: string): string[]|any /*undefined*/;
/**
* Gets the serialized key codes that the shortcut with the given name is
* registered under.
* @param {string} shortcutName The name of the shortcut.
* @return {!Array<string>} An array with all the key codes the shortcut is
* registered under.
* @public
*/
getKeyCodesByShortcutName(shortcutName: string): string[];
/**
* Creates the serialized key code that will be used in the key map.
* @param {number} keyCode Number code representing the key.
* @param {?Array<string>} modifiers List of modifier key codes to be used with
* the key. All valid modifiers can be found in the
* Blockly.ShortcutRegistry.modifierKeys.
* @return {string} The serialized key code for the given modifiers and key.
* @public
*/
createSerializedKey(keyCode: number, modifiers: string[]): string;
}
}
declare module Blockly.ShortcutRegistry {
/**
* Enum of valid modifiers.
* @enum {!Blockly.utils.KeyCodes<number>}
*/
enum modifierKeys { Shift, Control, Alt, Meta }
/**
* A keyboard shortcut.
* @typedef {{
* callback: ((function(!Blockly.Workspace, Event,
* !Blockly.ShortcutRegistry.KeyboardShortcut):boolean)|undefined),
* name: string,
* preconditionFn: ((function(!Blockly.Workspace):boolean)|undefined),
* metadata: (Object|undefined)
* }}
*/
interface KeyboardShortcut {
callback: { (_0: Blockly.Workspace, _1: Event, _2: Blockly.ShortcutRegistry.KeyboardShortcut): boolean }|any /*undefined*/;
name: string;
preconditionFn: { (_0: Blockly.Workspace): boolean }|any /*undefined*/;
metadata: Object|any /*undefined*/
}
}
declare module Blockly {
class Theme extends Theme__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Theme__Class {
/**
* Class for a theme.
* @param {string} name Theme name.
* @param {!Object<string, Blockly.Theme.BlockStyle>=} opt_blockStyles A map
* from style names (strings) to objects with style attributes for blocks.
* @param {!Object<string, Blockly.Theme.CategoryStyle>=} opt_categoryStyles A
* map from style names (strings) to objects with style attributes for
* categories.
* @param {!Blockly.Theme.ComponentStyle=} opt_componentStyles A map of Blockly
* component names to style value.
* @constructor
*/
constructor(name: string, opt_blockStyles?: { [key: string]: Blockly.Theme.BlockStyle }, opt_categoryStyles?: { [key: string]: Blockly.Theme.CategoryStyle }, opt_componentStyles?: Blockly.Theme.ComponentStyle);
/**
* The theme name. This can be used to reference a specific theme in CSS.
* @type {string}
*/
name: string;
/**
* The block styles map.
* @type {!Object<string, !Blockly.Theme.BlockStyle>}
* @package
*/
blockStyles: { [key: string]: Blockly.Theme.BlockStyle };
/**
* The category styles map.
* @type {!Object<string, Blockly.Theme.CategoryStyle>}
* @package
*/
categoryStyles: { [key: string]: Blockly.Theme.CategoryStyle };
/**
* The UI components styles map.
* @type {!Blockly.Theme.ComponentStyle}
* @package
*/
componentStyles: Blockly.Theme.ComponentStyle;
/**
* The font style.
* @type {!Blockly.Theme.FontStyle}
* @package
*/
fontStyle: Blockly.Theme.FontStyle;
/**
* Whether or not to add a 'hat' on top of all blocks with no previous or
* output connections.
* @type {?boolean}
* @package
*/
startHats: boolean;
/**
* Gets the class name that identifies this theme.
* @return {string} The CSS class name.
* @package
*/
getClassName(): string;
/**
* Overrides or adds a style to the blockStyles map.
* @param {string} blockStyleName The name of the block style.
* @param {Blockly.Theme.BlockStyle} blockStyle The block style.
*/
setBlockStyle(blockStyleName: string, blockStyle: Blockly.Theme.BlockStyle): void;
/**
* Overrides or adds a style to the categoryStyles map.
* @param {string} categoryStyleName The name of the category style.
* @param {Blockly.Theme.CategoryStyle} categoryStyle The category style.
*/
setCategoryStyle(categoryStyleName: string, categoryStyle: Blockly.Theme.CategoryStyle): void;
/**
* Gets the style for a given Blockly UI component. If the style value is a
* string, we attempt to find the value of any named references.
* @param {string} componentName The name of the component.
* @return {?string} The style value.
*/
getComponentStyle(componentName: string): string;
/**
* Configure a specific Blockly UI component with a style value.
* @param {string} componentName The name of the component.
* @param {*} styleValue The style value.
*/
setComponentStyle(componentName: string, styleValue: any): void;
/**
* Configure a theme's font style.
* @param {Blockly.Theme.FontStyle} fontStyle The font style.
*/
setFontStyle(fontStyle: Blockly.Theme.FontStyle): void;
/**
* Configure a theme's start hats.
* @param {boolean} startHats True if the theme enables start hats, false
* otherwise.
*/
setStartHats(startHats: boolean): void;
}
}
declare module Blockly.Theme {
/**
* A block style.
* @typedef {{
* colourPrimary:string,
* colourSecondary:string,
* colourTertiary:string,
* hat:string
* }}
*/
interface BlockStyle {
colourPrimary: string;
colourSecondary: string;
colourTertiary: string;
hat: string
}
/**
* A category style.
* @typedef {{
* colour:string
* }}
*/
interface CategoryStyle {
colour: string
}
/**
* A component style.
* @typedef {{
* workspaceBackgroundColour:?string,
* toolboxBackgroundColour:?string,
* toolboxForegroundColour:?string,
* flyoutBackgroundColour:?string,
* flyoutForegroundColour:?string,
* flyoutOpacity:?number,
* scrollbarColour:?string,
* scrollbarOpacity:?number,
* insertionMarkerColour:?string,
* insertionMarkerOpacity:?number,
* markerColour:?string,
* cursorColour:?string,
* selectedGlowColour:?string,
* selectedGlowOpacity:?number,
* replacementGlowColour:?string,
* replacementGlowOpacity:?number
* }}
*/
interface ComponentStyle {
workspaceBackgroundColour: string;
toolboxBackgroundColour: string;
toolboxForegroundColour: string;
flyoutBackgroundColour: string;
flyoutForegroundColour: string;
flyoutOpacity: number;
scrollbarColour: string;
scrollbarOpacity: number;
insertionMarkerColour: string;
insertionMarkerOpacity: number;
markerColour: string;
cursorColour: string;
selectedGlowColour: string;
selectedGlowOpacity: number;
replacementGlowColour: string;
replacementGlowOpacity: number
}
/**
* A font style.
* @typedef {{
* family:?string,
* weight:?string,
* size:?number
* }}
*/
interface FontStyle {
family: string;
weight: string;
size: number
}
/**
* Define a new Blockly theme.
* @param {string} name The name of the theme.
* @param {!Object} themeObj An object containing theme properties.
* @return {!Blockly.Theme} A new Blockly theme.
*/
function defineTheme(name: string, themeObj: Object): Blockly.Theme;
}
declare module Blockly {
class ThemeManager extends ThemeManager__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class ThemeManager__Class {
/**
* Class for storing and updating a workspace's theme and UI components.
* @param {!Blockly.WorkspaceSvg} workspace The main workspace.
* @param {!Blockly.Theme} theme The workspace theme.
* @constructor
* @package
*/
constructor(workspace: Blockly.WorkspaceSvg, theme: Blockly.Theme);
/**
* Get the workspace theme.
* @return {!Blockly.Theme} The workspace theme.
* @package
*/
getTheme(): Blockly.Theme;
/**
* Set the workspace theme, and refresh the workspace and all components.
* @param {!Blockly.Theme} theme The workspace theme.
* @package
*/
setTheme(theme: Blockly.Theme): void;
/**
* Subscribe a workspace to changes to the selected theme. If a new theme is
* set, the workspace is called to refresh its blocks.
* @param {!Blockly.Workspace} workspace The workspace to subscribe.
* @package
*/
subscribeWorkspace(workspace: Blockly.Workspace): void;
/**
* Unsubscribe a workspace to changes to the selected theme.
* @param {!Blockly.Workspace} workspace The workspace to unsubscribe.
* @package
*/
unsubscribeWorkspace(workspace: Blockly.Workspace): void;
/**
* Subscribe an element to changes to the selected theme. If a new theme is
* selected, the element's style is refreshed with the new theme's style.
* @param {!Element} element The element to subscribe.
* @param {string} componentName The name used to identify the component. This
* must be the same name used to configure the style in the Theme object.
* @param {string} propertyName The inline style property name to update.
* @package
*/
subscribe(element: Element, componentName: string, propertyName: string): void;
/**
* Unsubscribe an element to changes to the selected theme.
* @param {Element} element The element to unsubscribe.
* @package
*/
unsubscribe(element: Element): void;
/**
* Dispose of this theme manager.
* @package
* @suppress {checkTypes}
*/
dispose(): void;
}
}
declare module Blockly.ThemeManager {
/**
* A Blockly UI component type.
* @typedef {{
* element:!Element,
* propertyName:string
* }}
*/
interface Component {
element: Element;
propertyName: string
}
}
declare module Blockly.Tooltip {
/**
* A type which can define a tooltip.
* Either a string, an object containing a tooltip property, or a function which
* returns either a string, or another arbitrarily nested function which
* eventually unwinds to a string.
* @typedef {string|{tooltip}|function(): (string|!Function)}
*/
type TipInfo = string|{ tooltip: any /*missing*/ }|{ (): string|Function };
/**
* Is a tooltip currently showing?
*/
var visible: any /*missing*/;
/**
* Maximum width (in characters) of a tooltip.
*/
var LIMIT: any /*missing*/;
/**
* Horizontal offset between mouse cursor and tooltip.
*/
var OFFSET_X: any /*missing*/;
/**
* Vertical offset between mouse cursor and tooltip.
*/
var OFFSET_Y: any /*missing*/;
/**
* Radius mouse can move before killing tooltip.
*/
var RADIUS_OK: any /*missing*/;
/**
* Delay before tooltip appears.
*/
var HOVER_MS: any /*missing*/;
/**
* Horizontal padding between tooltip and screen edge.
*/
var MARGINS: any /*missing*/;
/**
* The HTML container. Set once by Blockly.Tooltip.createDom.
* @type {Element}
*/
var DIV: Element;
/**
* Returns the tooltip text for the given element.
* @param {?Object} object The object to get the tooltip text of.
* @return {string} The tooltip text of the element.
*/
function getTooltipOfObject(object: Object): string;
/**
* Create the tooltip div and inject it onto the page.
*/
function createDom(): void;
/**
* Binds the required mouse events onto an SVG element.
* @param {!Element} element SVG element onto which tooltip is to be bound.
*/
function bindMouseEvents(element: Element): void;
/**
* Unbinds tooltip mouse events from the SVG element.
* @param {!Element} element SVG element onto which tooltip is bound.
*/
function unbindMouseEvents(element: Element): void;
/**
* Dispose of the tooltip.
* @package
*/
function dispose(): void;
/**
* Hide the tooltip.
*/
function hide(): void;
/**
* Hide any in-progress tooltips and block showing new tooltips until the next
* call to unblock().
* @package
*/
function block(): void;
/**
* Unblock tooltips: allow them to be scheduled and shown according to their own
* logic.
* @package
*/
function unblock(): void;
}
declare module Blockly.Touch {
/**
* Whether touch is enabled in the browser.
* Copied from Closure's goog.events.BrowserFeature.TOUCH_ENABLED
*/
var TOUCH_ENABLED: any /*missing*/;
/**
* The TOUCH_MAP lookup dictionary specifies additional touch events to fire,
* in conjunction with mouse events.
* @type {Object}
*/
var TOUCH_MAP: Object;
/**
* Clear the touch identifier that tracks which touch stream to pay attention
* to. This ends the current drag/gesture and allows other pointers to be
* captured.
*/
function clearTouchIdentifier(): void;
/**
* Decide whether Blockly should handle or ignore this event.
* Mouse and touch events require special checks because we only want to deal
* with one touch stream at a time. All other events should always be handled.
* @param {!Event} e The event to check.
* @return {boolean} True if this event should be passed through to the
* registered handler; false if it should be blocked.
*/
function shouldHandleEvent(e: Event): boolean;
/**
* Get the touch identifier from the given event. If it was a mouse event, the
* identifier is the string 'mouse'.
* @param {!Event} e Mouse event or touch event.
* @return {string} The touch identifier from the first changed touch, if
* defined. Otherwise 'mouse'.
*/
function getTouchIdentifierFromEvent(e: Event): string;
/**
* Check whether the touch identifier on the event matches the current saved
* identifier. If there is no identifier, that means it's a mouse event and
* we'll use the identifier "mouse". This means we won't deal well with
* multiple mice being used at the same time. That seems okay.
* If the current identifier was unset, save the identifier from the
* event. This starts a drag/gesture, during which touch events with other
* identifiers will be silently ignored.
* @param {!Event} e Mouse event or touch event.
* @return {boolean} Whether the identifier on the event matches the current
* saved identifier.
*/
function checkTouchIdentifier(e: Event): boolean;
/**
* Set an event's clientX and clientY from its first changed touch. Use this to
* make a touch event work in a mouse event handler.
* @param {!Event} e A touch event.
*/
function setClientFromTouch(e: Event): void;
/**
* Check whether a given event is a mouse or touch event.
* @param {!Event} e An event.
* @return {boolean} True if it is a mouse or touch event; false otherwise.
*/
function isMouseOrTouchEvent(e: Event): boolean;
/**
* Check whether a given event is a touch event or a pointer event.
* @param {!Event} e An event.
* @return {boolean} True if it is a touch event; false otherwise.
*/
function isTouchEvent(e: Event): boolean;
/**
* Split an event into an array of events, one per changed touch or mouse
* point.
* @param {!Event} e A mouse event or a touch event with one or more changed
* touches.
* @return {!Array<!Event>} An array of mouse or touch events. Each touch
* event will have exactly one changed touch.
*/
function splitEventByTouches(e: Event): Event[];
}
declare module Blockly {
/**
* Context menus on touch devices are activated using a long-press.
* Unfortunately the contextmenu touch event is currently (2015) only supported
* by Chrome. This function is fired on any touchstart event, queues a task,
* which after about a second opens the context menu. The tasks is killed
* if the touch event terminates early.
* @param {!Event} e Touch start event.
* @param {Blockly.Gesture} gesture The gesture that triggered this longStart.
* @package
*/
function longStart(e: Event, gesture: Blockly.Gesture): void;
/**
* Nope, that's not a long-press. Either touchend or touchcancel was fired,
* or a drag hath begun. Kill the queued long-press task.
* @package
*/
function longStop_(): void;
}
declare module Blockly {
class TouchGesture extends TouchGesture__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class TouchGesture__Class extends Blockly.Gesture__Class {
/**
* Class for one gesture.
* @param {!Event} e The event that kicked off this gesture.
* @param {!Blockly.WorkspaceSvg} creatorWorkspace The workspace that created
* this gesture and has a reference to it.
* @extends {Blockly.Gesture}
* @constructor
*/
constructor(e: Event, creatorWorkspace: Blockly.WorkspaceSvg);
/**
* Start a gesture: update the workspace to indicate that a gesture is in
* progress and bind mousemove and mouseup handlers.
* @param {!Event} e A mouse down, touch start or pointer down event.
* @package
*/
doStart(e: Event): void;
/**
* Bind gesture events.
* Overriding the gesture definition of this function, binding the same
* functions for onMoveWrapper_ and onUpWrapper_ but passing
* opt_noCaptureIdentifier.
* In addition, binding a second mouse down event to detect multi-touch events.
* @param {!Event} e A mouse down or touch start event.
* @package
*/
bindMouseEvents(e: Event): void;
/**
* Handle a mouse down, touch start, or pointer down event.
* @param {!Event} e A mouse down, touch start, or pointer down event.
* @package
*/
handleStart(e: Event): void;
/**
* Handle a mouse move, touch move, or pointer move event.
* @param {!Event} e A mouse move, touch move, or pointer move event.
* @package
*/
handleMove(e: Event): void;
/**
* Handle a mouse up, touch end, or pointer up event.
* @param {!Event} e A mouse up, touch end, or pointer up event.
* @package
*/
handleUp(e: Event): void;
/**
* Whether this gesture is part of a multi-touch gesture.
* @return {boolean} Whether this gesture is part of a multi-touch gesture.
* @package
*/
isMultiTouch(): boolean;
/**
* Sever all links from this object.
* @package
*/
dispose(): void;
/**
* Handle a touch start or pointer down event and keep track of current
* pointers.
* @param {!Event} e A touch start, or pointer down event.
* @package
*/
handleTouchStart(e: Event): void;
/**
* Handle a touch move or pointer move event and zoom in/out if two pointers
* are on the screen.
* @param {!Event} e A touch move, or pointer move event.
* @package
*/
handleTouchMove(e: Event): void;
/**
* Handle a touch end or pointer end event and end the gesture.
* @param {!Event} e A touch end, or pointer end event.
* @package
*/
handleTouchEnd(e: Event): void;
/**
* Helper function returning the current touch point coordinate.
* @param {!Event} e A touch or pointer event.
* @return {?Blockly.utils.Coordinate} The current touch point coordinate
* @package
*/
getTouchPoint(e: Event): Blockly.utils.Coordinate;
}
}
declare module Blockly.TouchGesture {
/**
* A multiplier used to convert the gesture scale to a zoom in delta.
* @const
*/
var ZOOM_IN_MULTIPLIER: any /*missing*/;
/**
* A multiplier used to convert the gesture scale to a zoom out delta.
* @const
*/
var ZOOM_OUT_MULTIPLIER: any /*missing*/;
}
declare module Blockly {
class Trashcan extends Trashcan__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Trashcan__Class extends Blockly.DeleteArea__Class implements Blockly.IAutoHideable, Blockly.IPositionable {
/**
* Class for a trash can.
* @param {!Blockly.WorkspaceSvg} workspace The workspace to sit in.
* @constructor
* @implements {Blockly.IAutoHideable}
* @implements {Blockly.IPositionable}
* @extends {Blockly.DeleteArea}
*/
constructor(workspace: Blockly.WorkspaceSvg);
/**
* The unique id for this component that is used to register with the
* ComponentManager.
* @type {string}
*/
id: string;
/**
* The trashcan flyout.
* @type {Blockly.IFlyout}
* @package
*/
flyout: Blockly.IFlyout;
/**
* Current open/close state of the lid.
* @type {boolean}
*/
isLidOpen: boolean;
/**
* Create the trash can elements.
* @return {!SVGElement} The trash can's SVG group.
*/
createDom(): SVGElement;
/**
* Initializes the trash can.
*/
init(): void;
/**
* Dispose of this trash can.
* Unlink from all DOM elements to prevent memory leaks.
* @suppress {checkTypes}
*/
dispose(): void;
/**
* Returns true if the trashcan contents-flyout is currently open.
* @return {boolean} True if the trashcan contents-flyout is currently open.
*/
contentsIsOpen(): boolean;
/**
* Opens the trashcan flyout.
*/
openFlyout(): void;
/**
* Closes the trashcan flyout.
*/
closeFlyout(): void;
/**
* Hides the component. Called in Blockly.hideChaff.
* @param {boolean} onlyClosePopups Whether only popups should be closed.
* Flyouts should not be closed if this is true.
*/
autoHide(onlyClosePopups: boolean): void;
/**
* Empties the trashcan's contents. If the contents-flyout is currently open
* it will be closed.
*/
emptyContents(): void;
/**
* Positions the trashcan.
* It is positioned in the opposite corner to the corner the
* categories/toolbox starts at.
* @param {!Blockly.MetricsManager.UiMetrics} metrics The workspace metrics.
* @param {!Array<!Blockly.utils.Rect>} savedPositions List of rectangles that
* are already on the workspace.
*/
position(metrics: Blockly.MetricsManager.UiMetrics, savedPositions: Blockly.utils.Rect[]): void;
/**
* Returns the bounding rectangle of the UI element in pixel units relative to
* the Blockly injection div.
* @return {?Blockly.utils.Rect} The UI elements’s bounding box. Null if
* bounding box should be ignored by other UI elements.
*/
getBoundingRectangle(): Blockly.utils.Rect;
/**
* Returns the bounding rectangle of the drag target area in pixel units
* relative to viewport.
* @return {?Blockly.utils.Rect} The component's bounding box. Null if drag
* target area should be ignored.
*/
getClientRect(): Blockly.utils.Rect;
/**
* Flip the lid open or shut.
* @param {boolean} state True if open.
* @package
*/
setLidOpen(state: boolean): void;
/**
* Flip the lid shut.
* Called externally after a drag.
*/
closeLid(): void;
/**
* Inspect the contents of the trash.
*/
click(): void;
}
}
declare module Blockly.utils {
/**
* Don't do anything for this event, just halt propagation.
* @param {!Event} e An event.
*/
function noEvent(e: Event): void;
/**
* Is this event targeting a text input widget?
* @param {!Event} e An event.
* @return {boolean} True if text input.
*/
function isTargetInput(e: Event): boolean;
/**
* Return the coordinates of the top-left corner of this element relative to
* its parent. Only for SVG elements and children (e.g. rect, g, path).
* @param {!Element} element SVG element to find the coordinates of.
* @return {!Blockly.utils.Coordinate} Object with .x and .y properties.
*/
function getRelativeXY(element: Element): Blockly.utils.Coordinate;
/**
* Return the coordinates of the top-left corner of this element relative to
* the div Blockly was injected into.
* @param {!Element} element SVG element to find the coordinates of. If this is
* not a child of the div Blockly was injected into, the behaviour is
* undefined.
* @return {!Blockly.utils.Coordinate} Object with .x and .y properties.
*/
function getInjectionDivXY_(element: Element): Blockly.utils.Coordinate;
/**
* Is this event a right-click?
* @param {!Event} e Mouse event.
* @return {boolean} True if right-click.
*/
function isRightButton(e: Event): boolean;
/**
* Return the converted coordinates of the given mouse event.
* The origin (0,0) is the top-left corner of the Blockly SVG.
* @param {!Event} e Mouse event.
* @param {!Element} svg SVG element.
* @param {?SVGMatrix} matrix Inverted screen CTM to use.
* @return {!SVGPoint} Object with .x and .y properties.
*/
function mouseToSvg(e: Event, svg: Element, matrix: SVGMatrix): SVGPoint;
/**
* Get the scroll delta of a mouse event in pixel units.
* @param {!Event} e Mouse event.
* @return {{x: number, y: number}} Scroll delta object with .x and .y
* properties.
*/
function getScrollDeltaPixels(e: Event): { x: number; y: number };
/**
* Parse a string with any number of interpolation tokens (%1, %2, ...).
* It will also replace string table references (e.g., %{bky_my_msg} and
* %{BKY_MY_MSG} will both be replaced with the value in
* Blockly.Msg['MY_MSG']). Percentage sign characters '%' may be self-escaped
* (e.g., '%%').
* @param {string} message Text which might contain string table references and
* interpolation tokens.
* @return {!Array<string|number>} Array of strings and numbers.
*/
function tokenizeInterpolation(message: string): string|number[];
/**
* Replaces string table references in a message, if the message is a string.
* For example, "%{bky_my_msg}" and "%{BKY_MY_MSG}" will both be replaced with
* the value in Blockly.Msg['MY_MSG'].
* @param {string|?} message Message, which may be a string that contains
* string table references.
* @return {string} String with message references replaced.
*/
function replaceMessageReferences(message: string|any): string;
/**
* Validates that any %{MSG_KEY} references in the message refer to keys of
* the Blockly.Msg string table.
* @param {string} message Text which might contain string table references.
* @return {boolean} True if all message references have matching values.
* Otherwise, false.
*/
function checkMessageReferences(message: string): boolean;
/**
* Generate a unique ID. This should be globally unique.
* 87 characters ^ 20 length > 128 bits (better than a UUID).
* @return {string} A globally unique ID string.
*/
function genUid(): string;
/**
* Check if 3D transforms are supported by adding an element
* and attempting to set the property.
* @return {boolean} True if 3D transforms are supported.
*/
function is3dSupported(): boolean;
/**
* Calls a function after the page has loaded, possibly immediately.
* @param {function()} fn Function to run.
* @throws Error Will throw if no global document can be found (e.g., Node.js).
*/
function runAfterPageLoad(fn: { (): any /*missing*/ }): void;
/**
* Get the position of the current viewport in window coordinates. This takes
* scroll into account.
* @return {!Blockly.utils.Rect} An object containing window width, height, and
* scroll position in window coordinates.
* @package
*/
function getViewportBBox(): Blockly.utils.Rect;
/**
* Removes the first occurrence of a particular value from an array.
* @param {!Array} arr Array from which to remove
* value.
* @param {*} obj Object to remove.
* @return {boolean} True if an element was removed.
* @package
*/
function arrayRemove(arr: any[], obj: any): boolean;
/**
* Gets the document scroll distance as a coordinate object.
* Copied from Closure's goog.dom.getDocumentScroll.
* @return {!Blockly.utils.Coordinate} Object with values 'x' and 'y'.
*/
function getDocumentScroll(): Blockly.utils.Coordinate;
/**
* Get a map of all the block's descendants mapping their type to the number of
* children with that type.
* @param {!Blockly.Block} block The block to map.
* @param {boolean=} opt_stripFollowing Optionally ignore all following
* statements (blocks that are not inside a value or statement input
* of the block).
* @return {!Object} Map of types to type counts for descendants of the bock.
*/
function getBlockTypeCounts(block: Blockly.Block, opt_stripFollowing?: boolean): Object;
/**
* Converts screen coordinates to workspace coordinates.
* @param {!Blockly.WorkspaceSvg} ws The workspace to find the coordinates on.
* @param {!Blockly.utils.Coordinate} screenCoordinates The screen coordinates to
* be converted to workspace coordinates
* @return {!Blockly.utils.Coordinate} The workspace coordinates.
* @package
*/
function screenToWsCoordinates(ws: Blockly.WorkspaceSvg, screenCoordinates: Blockly.utils.Coordinate): Blockly.utils.Coordinate;
/**
* Parse a block colour from a number or string, as provided in a block
* definition.
* @param {number|string} colour HSV hue value (0 to 360), #RRGGBB string,
* or a message reference string pointing to one of those two values.
* @return {{hue: ?number, hex: string}} An object containing the colour as
* a #RRGGBB string, and the hue if the input was an HSV hue value.
* @throws {Error} If the colour cannot be parsed.
*/
function parseBlockColour(colour: number|string): { hue: number; hex: string };
}
declare module Blockly {
class VariableMap extends VariableMap__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class VariableMap__Class {
/**
* Class for a variable map. This contains a dictionary data structure with
* variable types as keys and lists of variables as values. The list of
* variables are the type indicated by the key.
* @param {!Blockly.Workspace} workspace The workspace this map belongs to.
* @constructor
*/
constructor(workspace: Blockly.Workspace);
/**
* The workspace this map belongs to.
* @type {!Blockly.Workspace}
*/
workspace: Blockly.Workspace;
/**
* Clear the variable map.
*/
clear(): void;
/**
* Rename the given variable by updating its name in the variable map.
* @param {!Blockly.VariableModel} variable Variable to rename.
* @param {string} newName New variable name.
* @package
*/
renameVariable(variable: Blockly.VariableModel, newName: string): void;
/**
* Rename a variable by updating its name in the variable map. Identify the
* variable to rename with the given ID.
* @param {string} id ID of the variable to rename.
* @param {string} newName New variable name.
*/
renameVariableById(id: string, newName: string): void;
/**
* Create a variable with a given name, optional type, and optional ID.
* @param {string} name The name of the variable. This must be unique across
* variables and procedures.
* @param {?string=} opt_type The type of the variable like 'int' or 'string'.
* Does not need to be unique. Field_variable can filter variables based on
* their type. This will default to '' which is a specific type.
* @param {?string=} opt_id The unique ID of the variable. This will default to
* a UUID.
* @return {!Blockly.VariableModel} The newly created variable.
*/
createVariable(name: string, opt_type?: string, opt_id?: string): Blockly.VariableModel;
/**
* Delete a variable.
* @param {!Blockly.VariableModel} variable Variable to delete.
*/
deleteVariable(variable: Blockly.VariableModel): void;
/**
* Delete a variables by the passed in ID and all of its uses from this
* workspace. May prompt the user for confirmation.
* @param {string} id ID of variable to delete.
*/
deleteVariableById(id: string): void;
/**
* Deletes a variable and all of its uses from this workspace without asking the
* user for confirmation.
* @param {!Blockly.VariableModel} variable Variable to delete.
* @param {!Array<!Blockly.Block>} uses An array of uses of the variable.
* @package
*/
deleteVariableInternal(variable: Blockly.VariableModel, uses: Blockly.Block[]): void;
/**
* Find the variable by the given name and type and return it. Return null if
* it is not found.
* @param {string} name The name to check for.
* @param {?string=} opt_type The type of the variable. If not provided it
* defaults to the empty string, which is a specific type.
* @return {?Blockly.VariableModel} The variable with the given name, or null if
* it was not found.
*/
getVariable(name: string, opt_type?: string): Blockly.VariableModel;
/**
* Find the variable by the given ID and return it. Return null if not found.
* @param {string} id The ID to check for.
* @return {?Blockly.VariableModel} The variable with the given ID.
*/
getVariableById(id: string): Blockly.VariableModel;
/**
* Get a list containing all of the variables of a specified type. If type is
* null, return list of variables with empty string type.
* @param {?string} type Type of the variables to find.
* @return {!Array<!Blockly.VariableModel>} The sought after variables of the
* passed in type. An empty array if none are found.
*/
getVariablesOfType(type: string): Blockly.VariableModel[];
/**
* Return all variable and potential variable types. This list always contains
* the empty string.
* @param {?Blockly.Workspace} ws The workspace used to look for potential
* variables. This can be different than the workspace stored on this object
* if the passed in ws is a flyout workspace.
* @return {!Array<string>} List of variable types.
* @package
*/
getVariableTypes(ws: Blockly.Workspace): string[];
/**
* Return all variables of all types.
* @return {!Array<!Blockly.VariableModel>} List of variable models.
*/
getAllVariables(): Blockly.VariableModel[];
/**
* Returns all of the variable names of all types.
* @return {!Array<string>} All of the variable names of all types.
*/
getAllVariableNames(): string[];
/**
* Find all the uses of a named variable.
* @param {string} id ID of the variable to find.
* @return {!Array<!Blockly.Block>} Array of block usages.
*/
getVariableUsesById(id: string): Blockly.Block[];
}
}
declare module Blockly {
class VariableModel extends VariableModel__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class VariableModel__Class {
/**
* Class for a variable model.
* Holds information for the variable including name, ID, and type.
* @param {!Blockly.Workspace} workspace The variable's workspace.
* @param {string} name The name of the variable. This is the user-visible name
* (e.g. 'my var' or '私の変数'), not the generated name.
* @param {string=} opt_type The type of the variable like 'int' or 'string'.
* Does not need to be unique. Field_variable can filter variables based on
* their type. This will default to '' which is a specific type.
* @param {string=} opt_id The unique ID of the variable. This will default to
* a UUID.
* @see {Blockly.FieldVariable}
* @constructor
*/
constructor(workspace: Blockly.Workspace, name: string, opt_type?: string, opt_id?: string);
/**
* The workspace the variable is in.
* @type {!Blockly.Workspace}
*/
workspace: Blockly.Workspace;
/**
* The name of the variable, typically defined by the user. It may be
* changed by the user.
* @type {string}
*/
name: string;
/**
* The type of the variable, such as 'int' or 'sound_effect'. This may be
* used to build a list of variables of a specific type. By default this is
* the empty string '', which is a specific type.
* @see {Blockly.FieldVariable}
* @type {string}
*/
type: string;
/**
* @return {string} The ID for the variable.
*/
getId(): string;
}
}
declare module Blockly.VariableModel {
/**
* A custom compare function for the VariableModel objects.
* @param {Blockly.VariableModel} var1 First variable to compare.
* @param {Blockly.VariableModel} var2 Second variable to compare.
* @return {number} -1 if name of var1 is less than name of var2, 0 if equal,
* and 1 if greater.
* @package
*/
function compareByName(var1: Blockly.VariableModel, var2: Blockly.VariableModel): number;
}
declare module Blockly.Variables {
/**
* Constant to separate variable names from procedures and generated functions
* when running generators.
* @deprecated Use Blockly.VARIABLE_CATEGORY_NAME
*/
var NAME_TYPE: any /*missing*/;
/**
* Find all user-created variables that are in use in the workspace.
* For use by generators.
* To get a list of all variables on a workspace, including unused variables,
* call Workspace.getAllVariables.
* @param {!Blockly.Workspace} ws The workspace to search for variables.
* @return {!Array<!Blockly.VariableModel>} Array of variable models.
*/
function allUsedVarModels(ws: Blockly.Workspace): Blockly.VariableModel[];
/**
* Find all developer variables used by blocks in the workspace.
* Developer variables are never shown to the user, but are declared as global
* variables in the generated code.
* To declare developer variables, define the getDeveloperVariables function on
* your block and return a list of variable names.
* For use by generators.
* @param {!Blockly.Workspace} workspace The workspace to search.
* @return {!Array<string>} A list of non-duplicated variable names.
*/
function allDeveloperVariables(workspace: Blockly.Workspace): string[];
/**
* Construct the elements (blocks and button) required by the flyout for the
* variable category.
* @param {!Blockly.Workspace} workspace The workspace containing variables.
* @return {!Array<!Element>} Array of XML elements.
*/
function flyoutCategory(workspace: Blockly.Workspace): Element[];
/**
* Construct the blocks required by the flyout for the variable category.
* @param {!Blockly.Workspace} workspace The workspace containing variables.
* @return {!Array<!Element>} Array of XML block elements.
*/
function flyoutCategoryBlocks(workspace: Blockly.Workspace): Element[];
/**
* Return a new variable name that is not yet being used. This will try to
* generate single letter variable names in the range 'i' to 'z' to start with.
* If no unique name is located it will try 'i' to 'z', 'a' to 'h',
* then 'i2' to 'z2' etc. Skip 'l'.
* @param {!Blockly.Workspace} workspace The workspace to be unique in.
* @return {string} New variable name.
*/
function generateUniqueName(workspace: Blockly.Workspace): string;
/**
* Returns a unique name that is not present in the usedNames array. This
* will try to generate single letter names in the range a -> z (skip l). It
* will start with the character passed to startChar.
* @param {string} startChar The character to start the search at.
* @param {!Array<string>} usedNames A list of all of the used names.
* @return {string} A unique name that is not present in the usedNames array.
*/
function generateUniqueNameFromOptions(startChar: string, usedNames: string[]): string;
/**
* Handles "Create Variable" button in the default variables toolbox category.
* It will prompt the user for a variable name, including re-prompts if a name
* is already in use among the workspace's variables.
*
* Custom button handlers can delegate to this function, allowing variables
* types and after-creation processing. More complex customization (e.g.,
* prompting for variable type) is beyond the scope of this function.
*
* @param {!Blockly.Workspace} workspace The workspace on which to create the
* variable.
* @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 {string=} opt_type The type of the variable like 'int', 'string', or
* ''. This will default to '', which is a specific type.
*/
function createVariableButtonHandler(workspace: Blockly.Workspace, opt_callback?: { (_0: string): any /*missing*/ }, opt_type?: string): void;
/**
* Original name of Blockly.Variables.createVariableButtonHandler(..).
* @deprecated Use Blockly.Variables.createVariableButtonHandler(..).
*
* @param {!Blockly.Workspace} workspace The workspace on which to create the
* variable.
* @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 {string=} opt_type The type of the variable like 'int', 'string', or
* ''. This will default to '', which is a specific type.
*/
function createVariable(workspace: Blockly.Workspace, opt_callback?: { (_0: string): any /*missing*/ }, opt_type?: string): void;
/**
* Opens a prompt that allows the user to enter a new name for a variable.
* Triggers a rename if the new name is valid. Or re-prompts if there is a
* collision.
* @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.
*/
function renameVariable(workspace: Blockly.Workspace, variable: Blockly.VariableModel, opt_callback?: { (_0: string): any /*missing*/ }): void;
/**
* Prompt the user for a new variable name.
* @param {string} promptText The string of the prompt.
* @param {string} defaultText The default value to show in the prompt's field.
* @param {function(?string)} callback A callback. It will return the new
* variable name, or null if the user picked something illegal.
*/
function promptName(promptText: string, defaultText: string, callback: { (_0: string): any /*missing*/ }): void;
/**
* Check whether there exists a variable with the given name of any type.
* @param {string} name The name to search for.
* @param {!Blockly.Workspace} workspace The workspace to search for the
* variable.
* @return {?Blockly.VariableModel} The variable with the given name,
* or null if none was found.
*/
function nameUsedWithAnyType(name: string, workspace: Blockly.Workspace): Blockly.VariableModel;
/**
* Generate DOM objects representing a variable field.
* @param {!Blockly.VariableModel} variableModel The variable model to
* represent.
* @return {?Element} The generated DOM.
* @public
*/
function generateVariableFieldDom(variableModel: Blockly.VariableModel): Element;
/**
* Helper function to look up or create a variable on the given workspace.
* If no variable exists, creates and returns it.
* @param {!Blockly.Workspace} workspace The workspace to search for the
* variable. It may be a flyout workspace or main workspace.
* @param {?string} id The ID to use to look up or create the variable, or null.
* @param {string=} opt_name The string to use to look up or create the
* variable.
* @param {string=} opt_type The type to use to look up or create the variable.
* @return {!Blockly.VariableModel} The variable corresponding to the given ID
* or name + type combination.
*/
function getOrCreateVariablePackage(workspace: Blockly.Workspace, id: string, opt_name?: string, opt_type?: string): Blockly.VariableModel;
/**
* Look up a variable on the given workspace.
* Always looks in the main workspace before looking in the flyout workspace.
* Always prefers lookup by ID to lookup by name + type.
* @param {!Blockly.Workspace} workspace The workspace to search for the
* variable. It may be a flyout workspace or main workspace.
* @param {?string} id The ID to use to look up the variable, or null.
* @param {string=} opt_name The string to use to look up the variable.
* Only used if lookup by ID fails.
* @param {string=} opt_type The type to use to look up the variable.
* Only used if lookup by ID fails.
* @return {?Blockly.VariableModel} The variable corresponding to the given ID
* or name + type combination, or null if not found.
* @public
*/
function getVariable(workspace: Blockly.Workspace, id: string, opt_name?: string, opt_type?: string): Blockly.VariableModel;
/**
* Helper function to get the list of variables that have been added to the
* workspace after adding a new block, using the given list of variables that
* were in the workspace before the new block was added.
* @param {!Blockly.Workspace} workspace The workspace to inspect.
* @param {!Array<!Blockly.VariableModel>} originalVariables The array of
* variables that existed in the workspace before adding the new block.
* @return {!Array<!Blockly.VariableModel>} The new array of variables that
* were freshly added to the workspace after creating the new block,
* or [] if no new variables were added to the workspace.
* @package
*/
function getAddedVariables(workspace: Blockly.Workspace, originalVariables: Blockly.VariableModel[]): Blockly.VariableModel[];
}
declare module Blockly.VariablesDynamic {
/**
* Construct the elements (blocks and button) required by the flyout for the
* variable category.
* @param {!Blockly.Workspace} workspace The workspace containing variables.
* @return {!Array<!Element>} Array of XML elements.
*/
function flyoutCategory(workspace: Blockly.Workspace): Element[];
/**
* Construct the blocks required by the flyout for the variable category.
* @param {!Blockly.Workspace} workspace The workspace containing variables.
* @return {!Array<!Element>} Array of XML block elements.
*/
function flyoutCategoryBlocks(workspace: Blockly.Workspace): Element[];
}
declare module Blockly {
class Warning extends Warning__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Warning__Class extends Blockly.Icon__Class {
/**
* Class for a warning.
* @param {!Blockly.Block} block The block associated with this warning.
* @extends {Blockly.Icon}
* @constructor
*/
constructor(block: Blockly.Block);
/**
* Does this icon get hidden when the block is collapsed.
*/
collapseHidden: any /*missing*/;
/**
* Draw the warning icon.
* @param {!Element} group The icon group.
* @protected
*/
drawIcon_(group: Element): void;
/**
* Show or hide the warning bubble.
* @param {boolean} visible True if the bubble should be visible.
*/
setVisible(visible: boolean): void;
/**
* Set this warning's text.
* @param {string} text Warning text (or '' to delete). This supports
* linebreaks.
* @param {string} id An ID for this text entry to be able to maintain
* multiple warnings.
*/
setText(text: string, id: string): void;
/**
* Get this warning's texts.
* @return {string} All texts concatenated into one string.
*/
getText(): string;
/**
* Dispose of this warning.
*/
dispose(): void;
}
}
declare module Blockly.WidgetDiv {
/**
* Create the widget div and inject it onto the page.
*/
function createDom(): void;
/**
* The HTML container for popup overlays (e.g. editor widgets).
* @type {!Element}
*/
var DIV: Element;
/**
* Initialize and display the widget div. Close the old one if needed.
* @param {!Object} newOwner The object that will be using this container.
* @param {boolean} rtl Right-to-left (true) or left-to-right (false).
* @param {Function} dispose Optional cleanup function to be run when the
* widget is closed.
*/
function show(newOwner: Object, rtl: boolean, dispose: Function): void;
/**
* Destroy the widget and hide the div.
*/
function hide(): void;
/**
* Is the container visible?
* @return {boolean} True if visible.
*/
function isVisible(): boolean;
/**
* Destroy the widget and hide the div if it is being used by the specified
* object.
* @param {!Object} oldOwner The object that was using this container.
*/
function hideIfOwner(oldOwner: Object): void;
/**
* Position the widget div based on an anchor rectangle.
* The widget should be placed adjacent to but not overlapping the anchor
* rectangle. The preferred position is directly below and aligned to the left
* (LTR) or right (RTL) side of the anchor.
* @param {!Blockly.utils.Rect} viewportBBox The bounding rectangle of the
* current viewport, in window coordinates.
* @param {!Blockly.utils.Rect} anchorBBox The bounding rectangle of the anchor,
* in window coordinates.
* @param {!Blockly.utils.Size} widgetSize The size of the widget that is inside
* the widget div, in window coordinates.
* @param {boolean} rtl Whether the workspace is in RTL mode. This determines
* horizontal alignment.
* @package
*/
function positionWithAnchor(viewportBBox: Blockly.utils.Rect, anchorBBox: Blockly.utils.Rect, widgetSize: Blockly.utils.Size, rtl: boolean): void;
}
declare module Blockly {
class Workspace extends Workspace__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Workspace__Class implements Blockly.IASTNodeLocation {
/**
* Class for a workspace. This is a data structure that contains blocks.
* There is no UI, and can be created headlessly.
* @param {!Blockly.Options=} opt_options Dictionary of options.
* @constructor
* @implements {Blockly.IASTNodeLocation}
*/
constructor(opt_options?: Blockly.Options);
/** @type {string} */
id: string;
/** @type {!Blockly.Options} */
options: Blockly.Options;
/** @type {boolean} */
RTL: boolean;
/** @type {boolean} */
horizontalLayout: boolean;
/** @type {Blockly.utils.toolbox.Position} */
toolboxPosition: Blockly.utils.toolbox.Position;
/**
* An object that encapsulates logic for safety, type, and dragging checks.
* @type {!Blockly.IConnectionChecker}
*/
connectionChecker: Blockly.IConnectionChecker;
/**
* @type {!Array<!Blockly.Events.Abstract>}
* @protected
*/
undoStack_: Blockly.Events.Abstract[];
/**
* @type {!Array<!Blockly.Events.Abstract>}
* @protected
*/
redoStack_: Blockly.Events.Abstract[];
/**
* Returns `true` if the workspace is visible and `false` if it's headless.
* @type {boolean}
*/
rendered: boolean;
/**
* Returns `true` if the workspace is currently in the process of a bulk clear.
* @type {boolean}
* @package
*/
isClearing: boolean;
/**
* Maximum number of undo events in stack. `0` turns off undo, `Infinity` sets
* it to unlimited.
* @type {number}
*/
MAX_UNDO: number;
/**
* Set of databases for rapid lookup of connection locations.
* @type {Array<!Blockly.ConnectionDB>}
*/
connectionDBList: Blockly.ConnectionDB[];
/**
* Dispose of this workspace.
* Unlink from all DOM elements to prevent memory leaks.
* @suppress {checkTypes}
*/
dispose(): void;
/**
* Adds a block to the list of top blocks.
* @param {!Blockly.Block} block Block to add.
*/
addTopBlock(block: Blockly.Block): void;
/**
* Removes a block from the list of top blocks.
* @param {!Blockly.Block} block Block to remove.
*/
removeTopBlock(block: Blockly.Block): void;
/**
* Finds the top-level blocks and returns them. Blocks are optionally sorted
* by position; top to bottom (with slight LTR or RTL bias).
* @param {boolean} ordered Sort the list if true.
* @return {!Array<!Blockly.Block>} The top-level block objects.
*/
getTopBlocks(ordered: boolean): Blockly.Block[];
/**
* Add a block to the list of blocks keyed by type.
* @param {!Blockly.Block} block Block to add.
*/
addTypedBlock(block: Blockly.Block): void;
/**
* Remove a block from the list of blocks keyed by type.
* @param {!Blockly.Block} block Block to remove.
*/
removeTypedBlock(block: Blockly.Block): void;
/**
* Finds the blocks with the associated type and returns them. Blocks are
* optionally sorted by position; top to bottom (with slight LTR or RTL bias).
* @param {string} type The type of block to search for.
* @param {boolean} ordered Sort the list if true.
* @return {!Array<!Blockly.Block>} The blocks of the given type.
*/
getBlocksByType(type: string, ordered: boolean): Blockly.Block[];
/**
* Adds a comment to the list of top comments.
* @param {!Blockly.WorkspaceComment} comment comment to add.
* @package
*/
addTopComment(comment: Blockly.WorkspaceComment): void;
/**
* Removes a comment from the list of top comments.
* @param {!Blockly.WorkspaceComment} comment comment to remove.
* @package
*/
removeTopComment(comment: Blockly.WorkspaceComment): void;
/**
* Finds the top-level comments and returns them. Comments are optionally
* sorted by position; top to bottom (with slight LTR or RTL bias).
* @param {boolean} ordered Sort the list if true.
* @return {!Array<!Blockly.WorkspaceComment>} The top-level comment objects.
* @package
*/
getTopComments(ordered: boolean): Blockly.WorkspaceComment[];
/**
* Find all blocks in workspace. Blocks are optionally sorted
* by position; top to bottom (with slight LTR or RTL bias).
* @param {boolean} ordered Sort the list if true.
* @return {!Array<!Blockly.Block>} Array of blocks.
*/
getAllBlocks(ordered: boolean): Blockly.Block[];
/**
* Dispose of all blocks and comments in workspace.
*/
clear(): void;
/**
* Rename a variable by updating its name in the variable map. Identify the
* variable to rename with the given ID.
* @param {string} id ID of the variable to rename.
* @param {string} newName New variable name.
*/
renameVariableById(id: string, newName: string): void;
/**
* Create a variable with a given name, optional type, and optional ID.
* @param {string} name The name of the variable. This must be unique across
* variables and procedures.
* @param {?string=} opt_type The type of the variable like 'int' or 'string'.
* Does not need to be unique. Field_variable can filter variables based on
* their type. This will default to '' which is a specific type.
* @param {?string=} opt_id The unique ID of the variable. This will default to
* a UUID.
* @return {!Blockly.VariableModel} The newly created variable.
*/
createVariable(name: string, opt_type?: string, opt_id?: string): Blockly.VariableModel;
/**
* Find all the uses of the given variable, which is identified by ID.
* @param {string} id ID of the variable to find.
* @return {!Array<!Blockly.Block>} Array of block usages.
*/
getVariableUsesById(id: string): Blockly.Block[];
/**
* Delete a variables by the passed in ID and all of its uses from this
* workspace. May prompt the user for confirmation.
* @param {string} id ID of variable to delete.
*/
deleteVariableById(id: string): void;
/**
* Find the variable by the given name and return it. Return null if not found.
* @param {string} name The name to check for.
* @param {string=} opt_type The type of the variable. If not provided it
* defaults to the empty string, which is a specific type.
* @return {?Blockly.VariableModel} The variable with the given name.
*/
getVariable(name: string, opt_type?: string): Blockly.VariableModel;
/**
* Find the variable by the given ID and return it. Return null if not found.
* @param {string} id The ID to check for.
* @return {?Blockly.VariableModel} The variable with the given ID.
*/
getVariableById(id: string): Blockly.VariableModel;
/**
* Find the variable with the specified type. If type is null, return list of
* variables with empty string type.
* @param {?string} type Type of the variables to find.
* @return {!Array<!Blockly.VariableModel>} The sought after variables of the
* passed in type. An empty array if none are found.
*/
getVariablesOfType(type: string): Blockly.VariableModel[];
/**
* Return all variable types.
* @return {!Array<string>} List of variable types.
* @package
*/
getVariableTypes(): string[];
/**
* Return all variables of all types.
* @return {!Array<!Blockly.VariableModel>} List of variable models.
*/
getAllVariables(): Blockly.VariableModel[];
/**
* Returns all variable names of all types.
* @return {!Array<string>} List of all variable names of all types.
*/
getAllVariableNames(): string[];
/**
* Returns the horizontal offset of the workspace.
* Intended for LTR/RTL compatibility in XML.
* Not relevant for a headless workspace.
* @return {number} Width.
*/
getWidth(): number;
/**
* Obtain a newly created block.
* @param {!string} prototypeName Name of the language object containing
* type-specific functions for this block.
* @param {string=} opt_id Optional ID. Use this ID if provided, otherwise
* create a new ID.
* @return {!Blockly.Block} The created block.
*/
newBlock(prototypeName: string, opt_id?: string): Blockly.Block;
/**
* The number of blocks that may be added to the workspace before reaching
* the maxBlocks.
* @return {number} Number of blocks left.
*/
remainingCapacity(): number;
/**
* The number of blocks of the given type that may be added to the workspace
* before reaching the maxInstances allowed for that type.
* @param {string} type Type of block to return capacity for.
* @return {number} Number of blocks of type left.
*/
remainingCapacityOfType(type: string): number;
/**
* Check if there is remaining capacity for blocks of the given counts to be
* created. If the total number of blocks represented by the map is more than
* the total remaining capacity, it returns false. If a type count is more
* than the remaining capacity for that type, it returns false.
* @param {!Object} typeCountsMap A map of types to counts (usually representing
* blocks to be created).
* @return {boolean} True if there is capacity for the given map,
* false otherwise.
*/
isCapacityAvailable(typeCountsMap: Object): boolean;
/**
* Checks if the workspace has any limits on the maximum number of blocks,
* or the maximum number of blocks of specific types.
* @return {boolean} True if it has block limits, false otherwise.
*/
hasBlockLimits(): boolean;
/**
* Gets the undo stack for workplace.
* @return {!Array<!Blockly.Events.Abstract>} undo stack
* @package
*/
getUndoStack(): Blockly.Events.Abstract[];
/**
* Gets the redo stack for workplace.
* @return {!Array<!Blockly.Events.Abstract>} redo stack
* @package
*/
getRedoStack(): Blockly.Events.Abstract[];
/**
* Undo or redo the previous action.
* @param {boolean} redo False if undo, true if redo.
*/
undo(redo: boolean): void;
/**
* Clear the undo/redo stacks.
*/
clearUndo(): void;
/**
* When something in this workspace changes, call a function.
* Note that there may be a few recent events already on the stack. Thus the
* new change listener might be called with events that occurred a few
* milliseconds before the change listener was added.
* @param {!Function} func Function to call.
* @return {!Function} Obsolete return value, ignore.
*/
addChangeListener(func: Function): Function;
/**
* Stop listening for this workspace's changes.
* @param {!Function} func Function to stop calling.
*/
removeChangeListener(func: Function): void;
/**
* Fire a change event.
* @param {!Blockly.Events.Abstract} event Event to fire.
*/
fireChangeListener(event: Blockly.Events.Abstract): void;
/**
* Find the block on this workspace with the specified ID.
* @param {string} id ID of block to find.
* @return {?Blockly.Block} The sought after block, or null if not found.
*/
getBlockById(id: string): Blockly.Block;
/**
* Set a block on this workspace with the specified ID.
* @param {string} id ID of block to set.
* @param {Blockly.Block} block The block to set.
* @package
*/
setBlockById(id: string, block: Blockly.Block): void;
/**
* Delete a block off this workspace with the specified ID.
* @param {string} id ID of block to delete.
* @package
*/
removeBlockById(id: string): void;
/**
* Find the comment on this workspace with the specified ID.
* @param {string} id ID of comment to find.
* @return {?Blockly.WorkspaceComment} The sought after comment, or null if not
* found.
* @package
*/
getCommentById(id: string): Blockly.WorkspaceComment;
/**
* Checks whether all value and statement inputs in the workspace are filled
* with blocks.
* @param {boolean=} opt_shadowBlocksAreFilled An optional argument controlling
* whether shadow blocks are counted as filled. Defaults to true.
* @return {boolean} True if all inputs are filled, false otherwise.
*/
allInputsFilled(opt_shadowBlocksAreFilled?: boolean): boolean;
/**
* Return the variable map that contains "potential" variables.
* These exist in the flyout but not in the workspace.
* @return {?Blockly.VariableMap} The potential variable map.
* @package
*/
getPotentialVariableMap(): Blockly.VariableMap;
/**
* Create and store the potential variable map for this workspace.
* @package
*/
createPotentialVariableMap(): void;
/**
* Return the map of all variables on the workspace.
* @return {!Blockly.VariableMap} The variable map.
*/
getVariableMap(): Blockly.VariableMap;
/**
* Set the map of all variables on the workspace.
* @param {!Blockly.VariableMap} variableMap The variable map.
* @package
*/
setVariableMap(variableMap: Blockly.VariableMap): void;
}
}
declare module Blockly.Workspace {
/**
* Angle away from the horizontal to sweep for blocks. Order of execution is
* generally top to bottom, but a small angle changes the scan to give a bit of
* a left to right bias (reversed in RTL). Units are in degrees.
* See: https://tvtropes.org/pmwiki/pmwiki.php/Main/DiagonalBilling
*/
var SCAN_ANGLE: any /*missing*/;
/**
* Find the workspace with the specified ID.
* @param {string} id ID of workspace to find.
* @return {?Blockly.Workspace} The sought after workspace or null if not found.
*/
function getById(id: string): Blockly.Workspace;
/**
* Find all workspaces.
* @return {!Array<!Blockly.Workspace>} Array of workspaces.
*/
function getAll(): Blockly.Workspace[];
}
declare module Blockly {
class WorkspaceAudio extends WorkspaceAudio__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class WorkspaceAudio__Class {
/**
* Class for loading, storing, and playing audio for a workspace.
* @param {Blockly.WorkspaceSvg} parentWorkspace The parent of the workspace
* this audio object belongs to, or null.
* @constructor
*/
constructor(parentWorkspace: Blockly.WorkspaceSvg);
/**
* Dispose of this audio manager.
* @package
*/
dispose(): void;
/**
* Load an audio file. Cache it, ready for instantaneous playing.
* @param {!Array<string>} filenames List of file types in decreasing order of
* preference (i.e. increasing size). E.g. ['media/go.mp3', 'media/go.wav']
* Filenames include path from Blockly's root. File extensions matter.
* @param {string} name Name of sound.
*/
load(filenames: string[], name: string): void;
/**
* Preload all the audio files so that they play quickly when asked for.
* @package
*/
preload(): void;
/**
* Play a named sound at specified volume. If volume is not specified,
* use full volume (1).
* @param {string} name Name of sound.
* @param {number=} opt_volume Volume of sound (0-1).
*/
play(name: string, opt_volume?: number): void;
}
}
declare module Blockly {
class WorkspaceComment extends WorkspaceComment__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class WorkspaceComment__Class {
/**
* Class for a workspace comment.
* @param {!Blockly.Workspace} workspace The block's workspace.
* @param {string} content The content of this workspace comment.
* @param {number} height Height of the comment.
* @param {number} width Width of the comment.
* @param {string=} opt_id Optional ID. Use this ID if provided, otherwise
* create a new ID.
* @constructor
*/
constructor(workspace: Blockly.Workspace, content: string, height: number, width: number, opt_id?: string);
/** @type {string} */
id: string;
/**
* The comment's position in workspace units. (0, 0) is at the workspace's
* origin; scale does not change this value.
* @type {!Blockly.utils.Coordinate}
* @protected
*/
xy_: Blockly.utils.Coordinate;
/**
* @type {!Blockly.Workspace}
*/
workspace: Blockly.Workspace;
/**
* @protected
* @type {boolean}
*/
RTL: boolean;
/**
* @protected
* @type {string}
*/
content_: string;
/**
* @package
* @type {boolean}
*/
isComment: boolean;
/**
* Dispose of this comment.
* @package
*/
dispose(): void;
/**
* Get comment height.
* @return {number} Comment height.
* @package
*/
getHeight(): number;
/**
* Set comment height.
* @param {number} height Comment height.
* @package
*/
setHeight(height: number): void;
/**
* Get comment width.
* @return {number} Comment width.
* @package
*/
getWidth(): number;
/**
* Set comment width.
* @param {number} width comment width.
* @package
*/
setWidth(width: number): void;
/**
* Get stored location.
* @return {!Blockly.utils.Coordinate} The comment's stored location.
* This is not valid if the comment is currently being dragged.
* @package
*/
getXY(): Blockly.utils.Coordinate;
/**
* Move a comment by a relative offset.
* @param {number} dx Horizontal offset, in workspace units.
* @param {number} dy Vertical offset, in workspace units.
* @package
*/
moveBy(dx: number, dy: number): void;
/**
* Get whether this comment is deletable or not.
* @return {boolean} True if deletable.
* @package
*/
isDeletable(): boolean;
/**
* Set whether this comment is deletable or not.
* @param {boolean} deletable True if deletable.
* @package
*/
setDeletable(deletable: boolean): void;
/**
* Get whether this comment is movable or not.
* @return {boolean} True if movable.
* @package
*/
isMovable(): boolean;
/**
* Set whether this comment is movable or not.
* @param {boolean} movable True if movable.
* @package
*/
setMovable(movable: boolean): void;
/**
* Get whether this comment is editable or not.
* @return {boolean} True if editable.
*/
isEditable(): boolean;
/**
* Set whether this comment is editable or not.
* @param {boolean} editable True if editable.
*/
setEditable(editable: boolean): void;
/**
* Returns this comment's text.
* @return {string} Comment text.
* @package
*/
getContent(): string;
/**
* Set this comment's content.
* @param {string} content Comment content.
* @package
*/
setContent(content: string): void;
/**
* Encode a comment subtree as XML with XY coordinates.
* @param {boolean=} opt_noId True if the encoder should skip the comment ID.
* @return {!Element} Tree of XML elements.
* @package
*/
toXmlWithXY(opt_noId?: boolean): Element;
/**
* Encode a comment subtree as XML, but don't serialize the XY coordinates.
* This method avoids some expensive metrics-related calls that are made in
* toXmlWithXY().
* @param {boolean=} opt_noId True if the encoder should skip the comment ID.
* @return {!Element} Tree of XML elements.
* @package
*/
toXml(opt_noId?: boolean): Element;
}
}
declare module Blockly.WorkspaceComment {
/**
* Fire a create event for the given workspace comment, if comments are enabled.
* @param {!Blockly.WorkspaceComment} comment The comment that was just created.
* @package
*/
function fireCreateEvent(comment: Blockly.WorkspaceComment): void;
/**
* Decode an XML comment tag and create a comment on the workspace.
* @param {!Element} xmlComment XML comment element.
* @param {!Blockly.Workspace} workspace The workspace.
* @return {!Blockly.WorkspaceComment} The created workspace comment.
* @package
*/
function fromXml(xmlComment: Element, workspace: Blockly.Workspace): Blockly.WorkspaceComment;
/**
* Decode an XML comment tag and return the results in an object.
* @param {!Element} xml XML comment element.
* @return {{w: number, h: number, x: number, y: number, content: string}} An
* object containing the id, size, position, and comment string.
* @package
*/
function parseAttributes(xml: Element): { w: number; h: number; x: number; y: number; content: string };
}
declare module Blockly {
class WorkspaceCommentSvg extends WorkspaceCommentSvg__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class WorkspaceCommentSvg__Class extends Blockly.WorkspaceComment__Class implements Blockly.IBoundedElement, Blockly.IBubble, Blockly.ICopyable {
/**
* Class for a workspace comment's SVG representation.
* @param {!Blockly.Workspace} workspace The block's workspace.
* @param {string} content The content of this workspace comment.
* @param {number} height Height of the comment.
* @param {number} width Width of the comment.
* @param {string=} opt_id Optional ID. Use this ID if provided, otherwise
* create a new ID.
* @extends {Blockly.WorkspaceComment}
* @implements {Blockly.IBoundedElement}
* @implements {Blockly.IBubble}
* @implements {Blockly.ICopyable}
* @constructor
*/
constructor(workspace: Blockly.Workspace, content: string, height: number, width: number, opt_id?: string);
/**
* Dispose of this comment.
* @package
*/
dispose(): void;
/**
* Create and initialize the SVG representation of a workspace comment.
* May be called more than once.
*
* @param {boolean=} opt_noSelect Text inside text area will be selected if false
*
* @package
*/
initSvg(opt_noSelect?: boolean): void;
/**
* Show the context menu for this workspace comment.
* @param {!Event} e Mouse event.
* @package
*/
showContextMenu(e: Event): void;
/**
* Select this comment. Highlight it visually.
* @package
*/
select(): void;
/**
* Unselect this comment. Remove its highlighting.
* @package
*/
unselect(): void;
/**
* Select this comment. Highlight it visually.
* @package
*/
addSelect(): void;
/**
* Unselect this comment. Remove its highlighting.
* @package
*/
removeSelect(): void;
/**
* Focus this comment. Highlight it visually.
* @package
*/
addFocus(): void;
/**
* Unfocus this comment. Remove its highlighting.
* @package
*/
removeFocus(): void;
/**
* Return the coordinates of the top-left corner of this comment relative to
* the drawing surface's origin (0,0), in workspace units.
* If the comment is on the workspace, (0, 0) is the origin of the workspace
* coordinate system.
* This does not change with workspace scale.
* @return {!Blockly.utils.Coordinate} Object with .x and .y properties in
* workspace coordinates.
* @package
*/
getRelativeToSurfaceXY(): Blockly.utils.Coordinate;
/**
* Move a comment by a relative offset.
* @param {number} dx Horizontal offset, in workspace units.
* @param {number} dy Vertical offset, in workspace units.
* @package
*/
moveBy(dx: number, dy: number): void;
/**
* Transforms a comment by setting the translation on the transform attribute
* of the block's SVG.
* @param {number} x The x coordinate of the translation in workspace units.
* @param {number} y The y coordinate of the translation in workspace units.
* @package
*/
translate(x: number, y: number): void;
/**
* Move this comment to its workspace's drag surface, accounting for
* positioning. Generally should be called at the same time as
* setDragging(true). Does nothing if useDragSurface_ is false.
* @package
*/
moveToDragSurface(): void;
/**
* Move this comment during a drag, taking into account whether we are using a
* drag surface to translate blocks.
* @param {Blockly.BlockDragSurfaceSvg} dragSurface The surface that carries
* rendered items during a drag, or null if no drag surface is in use.
* @param {!Blockly.utils.Coordinate} newLoc The location to translate to, in
* workspace coordinates.
* @package
*/
moveDuringDrag(dragSurface: Blockly.BlockDragSurfaceSvg, newLoc: Blockly.utils.Coordinate): void;
/**
* Move the bubble group to the specified location in workspace coordinates.
* @param {number} x The x position to move to.
* @param {number} y The y position to move to.
* @package
*/
moveTo(x: number, y: number): void;
/**
* Returns the coordinates of a bounding box describing the dimensions of this
* comment.
* Coordinate system: workspace coordinates.
* @return {!Blockly.utils.Rect} Object with coordinates of the bounding box.
* @package
*/
getBoundingRectangle(): Blockly.utils.Rect;
/**
* Add or remove the UI indicating if this comment is movable or not.
* @package
*/
updateMovable(): void;
/**
* Set whether this comment is movable or not.
* @param {boolean} movable True if movable.
* @package
*/
setMovable(movable: boolean): void;
/**
* Set whether this comment is editable or not.
* @param {boolean} editable True if editable.
*/
setEditable(editable: boolean): void;
/**
* Recursively adds or removes the dragging class to this node and its children.
* @param {boolean} adding True if adding, false if removing.
* @package
*/
setDragging(adding: boolean): void;
/**
* Return the root node of the SVG or null if none exists.
* @return {!SVGElement} The root SVG node (probably a group).
* @package
*/
getSvgRoot(): SVGElement;
/**
* Returns this comment's text.
* @return {string} Comment text.
* @package
*/
getContent(): string;
/**
* Set this comment's content.
* @param {string} content Comment content.
* @package
*/
setContent(content: string): void;
/**
* Update the cursor over this comment by adding or removing a class.
* @param {boolean} enable True if the delete cursor should be shown, false
* otherwise.
* @package
*/
setDeleteStyle(enable: boolean): void;
/**
* Set whether auto-layout of this bubble is enabled. The first time a bubble
* is shown it positions itself to not cover any blocks. Once a user has
* dragged it to reposition, it renders where the user put it.
* @param {boolean} _enable True if auto-layout should be enabled, false
* otherwise.
* @package
*/
setAutoLayout(_enable: boolean): void;
/**
* Encode a comment subtree as XML with XY coordinates.
* @param {boolean=} opt_noId True if the encoder should skip the comment ID.
* @return {!Element} Tree of XML elements.
* @package
*/
toXmlWithXY(opt_noId?: boolean): Element;
/**
* Encode a comment for copying.
* @return {!Blockly.ICopyable.CopyData} Copy metadata.
* @package
*/
toCopyData(): Blockly.ICopyable.CopyData;
}
}
declare module Blockly.WorkspaceCommentSvg {
/**
* The width and height to use to size a workspace comment when it is first
* added, before it has been edited by the user.
* @type {number}
* @package
*/
var DEFAULT_SIZE: number;
/**
* Decode an XML comment tag and create a rendered comment on the workspace.
* @param {!Element} xmlComment XML comment element.
* @param {!Blockly.Workspace} workspace The workspace.
* @param {number=} opt_wsWidth The width of the workspace, which is used to
* position comments correctly in RTL.
* @return {!Blockly.WorkspaceCommentSvg} The created workspace comment.
* @package
*/
function fromXml(xmlComment: Element, workspace: Blockly.Workspace, opt_wsWidth?: number): Blockly.WorkspaceCommentSvg;
}
declare module Blockly {
class WorkspaceDragSurfaceSvg extends WorkspaceDragSurfaceSvg__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class WorkspaceDragSurfaceSvg__Class {
/**
* Blocks are moved into this SVG during a drag, improving performance.
* The entire SVG is translated using CSS transforms instead of SVG so the
* blocks are never repainted during drag improving performance.
* @param {!Element} container Containing element.
* @constructor
*/
constructor(container: Element);
/**
* Dom structure when the workspace is being dragged. If there is no drag in
* progress, the SVG is empty and display: none.
* <svg class="blocklyWsDragSurface" style=transform:translate3d(...)>
* <g class="blocklyBlockCanvas"></g>
* <g class="blocklyBubbleCanvas">/g>
* </svg>
*/
SVG_: any /*missing*/;
/**
* Create the drag surface and inject it into the container.
*/
createDom(): 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 {number} x X translation for the entire surface
* @param {number} y Y translation for the entire surface
* @package
*/
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.
* @return {!Blockly.utils.Coordinate} Current translation of the surface
* @package
*/
getSurfaceTranslation(): Blockly.utils.Coordinate;
/**
* Move the blockCanvas and bubbleCanvas out of the surface SVG and on to
* newSurface.
* @param {SVGElement} newSurface The element to put the drag surface contents
* into.
* @package
*/
clearAndHide(newSurface: SVGElement): void;
/**
* Set the SVG to have the block canvas and bubble canvas in it and then
* show the surface.
* @param {!SVGElement} blockCanvas The block canvas <g> element from the
* workspace.
* @param {!SVGElement} bubbleCanvas The <g> element that contains the bubbles.
* @param {Element} previousSibling The element to insert the block canvas and
bubble canvas after when it goes back in the DOM at the end of a drag.
* @param {number} width The width of the workspace SVG element.
* @param {number} height The height of the workspace SVG element.
* @param {number} scale The scale of the workspace being dragged.
* @package
*/
setContentsAndShow(blockCanvas: SVGElement, bubbleCanvas: SVGElement, previousSibling: Element, width: number, height: number, scale: number): void;
}
}
declare module Blockly {
class WorkspaceDragger extends WorkspaceDragger__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class WorkspaceDragger__Class {
/**
* Class for a workspace dragger. It moves the workspace around when it is
* being dragged by a mouse or touch.
* Note that the workspace itself manages whether or not it has a drag surface
* and how to do translations based on that. This simply passes the right
* commands based on events.
* @param {!Blockly.WorkspaceSvg} workspace The workspace to drag.
* @constructor
*/
constructor(workspace: Blockly.WorkspaceSvg);
/**
* The scroll position of the workspace at the beginning of the drag.
* Coordinate system: pixel coordinates.
* @type {!Blockly.utils.Coordinate}
* @protected
*/
startScrollXY_: Blockly.utils.Coordinate;
/**
* Sever all links from this object.
* @package
* @suppress {checkTypes}
*/
dispose(): void;
/**
* Start dragging the workspace.
* @package
*/
startDrag(): void;
/**
* Finish dragging the workspace and put everything back where it belongs.
* @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
* moved from the position at the start of the drag, in pixel coordinates.
* @package
*/
endDrag(currentDragDeltaXY: Blockly.utils.Coordinate): void;
/**
* Move the workspace based on the most recent mouse movements.
* @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
* moved from the position at the start of the drag, in pixel coordinates.
* @package
*/
drag(currentDragDeltaXY: Blockly.utils.Coordinate): void;
}
}
declare module Blockly {
class WorkspaceSvg extends WorkspaceSvg__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class WorkspaceSvg__Class extends Blockly.Workspace__Class implements Blockly.IASTNodeLocationSvg {
/**
* Class for a workspace. This is an onscreen area with optional trashcan,
* scrollbars, bubbles, and dragging.
* @param {!Blockly.Options} options Dictionary of options.
* @param {Blockly.BlockDragSurfaceSvg=} opt_blockDragSurface Drag surface for
* blocks.
* @param {Blockly.WorkspaceDragSurfaceSvg=} opt_wsDragSurface Drag surface for
* the workspace.
* @extends {Blockly.Workspace}
* @implements {Blockly.IASTNodeLocationSvg}
* @constructor
*/
constructor(options: Blockly.Options, opt_blockDragSurface?: Blockly.BlockDragSurfaceSvg, opt_wsDragSurface?: Blockly.WorkspaceDragSurfaceSvg);
/**
* Method to get all the metrics that have to do with a workspace.
* @type {function():!Blockly.utils.Metrics}
* @package
*/
getMetrics: { (): Blockly.utils.Metrics };
/**
* Translates the workspace.
* @type {function(!{x:number, y:number}):void}
* @package
*/
setMetrics: { (_0: { x: number; y: number }): void };
/**
* Object in charge of storing and updating the workspace theme.
* @type {!Blockly.ThemeManager}
* @protected
*/
themeManager_: Blockly.ThemeManager;
/**
* True if keyboard accessibility mode is on, false otherwise.
* @type {boolean}
*/
keyboardAccessibilityMode: boolean;
/**
* The render status of an SVG workspace.
* Returns `false` for headless workspaces and true for instances of
* `Blockly.WorkspaceSvg`.
* @type {boolean}
*/
rendered: boolean;
/**
* Is this workspace the surface for a flyout?
* @type {boolean}
*/
isFlyout: boolean;
/**
* Is this workspace the surface for a mutator?
* @type {boolean}
* @package
*/
isMutator: boolean;
/**
* Current horizontal scrolling offset in pixel units, relative to the
* workspace origin.
*
* It is useful to think about a view, and a canvas moving beneath that
* view. As the canvas moves right, this value becomes more positive, and
* the view is now "seeing" the left side of the canvas. As the canvas moves
* left, this value becomes more negative, and the view is now "seeing" the
* right side of the canvas.
*
* The confusing thing about this value is that it does not, and must not
* include the absoluteLeft offset. This is because it is used to calculate
* the viewLeft value.
*
* The viewLeft is relative to the workspace origin (although in pixel
* units). The workspace origin is the top-left corner of the workspace (at
* least when it is enabled). It is shifted from the top-left of the blocklyDiv
* so as not to be beneath the toolbox.
*
* When the workspace is enabled the viewLeft and workspace origin are at
* the same X location. As the canvas slides towards the right beneath the view
* this value (scrollX) becomes more positive, and the viewLeft becomes more
* negative relative to the workspace origin (imagine the workspace origin
* as a dot on the canvas sliding to the right as the canvas moves).
*
* So if the scrollX were to include the absoluteLeft this would in a way
* "unshift" the workspace origin. This means that the viewLeft would be
* representing the left edge of the blocklyDiv, rather than the left edge
* of the workspace.
*
* @type {number}
*/
scrollX: number;
/**
* Current vertical scrolling offset in pixel units, relative to the
* workspace origin.
*
* It is useful to think about a view, and a canvas moving beneath that
* view. As the canvas moves down, this value becomes more positive, and the
* view is now "seeing" the upper part of the canvas. As the canvas moves
* up, this value becomes more negative, and the view is "seeing" the lower
* part of the canvas.
*
* This confusing thing about this value is that it does not, and must not
* include the absoluteTop offset. This is because it is used to calculate
* the viewTop value.
*
* The viewTop is relative to the workspace origin (although in pixel
* units). The workspace origin is the top-left corner of the workspace (at
* least when it is enabled). It is shifted from the top-left of the
* blocklyDiv so as not to be beneath the toolbox.
*
* When the workspace is enabled the viewTop and workspace origin are at the
* same Y location. As the canvas slides towards the bottom this value
* (scrollY) becomes more positive, and the viewTop becomes more negative
* relative to the workspace origin (image in the workspace origin as a dot
* on the canvas sliding downwards as the canvas moves).
*
* So if the scrollY were to include the absoluteTop this would in a way
* "unshift" the workspace origin. This means that the viewTop would be
* representing the top edge of the blocklyDiv, rather than the top edge of
* the workspace.
*
* @type {number}
*/
scrollY: number;
/**
* Horizontal scroll value when scrolling started in pixel units.
* @type {number}
*/
startScrollX: number;
/**
* Vertical scroll value when scrolling started in pixel units.
* @type {number}
*/
startScrollY: number;
/**
* Current scale.
* @type {number}
*/
scale: number;
/** @type {Blockly.Trashcan} */
trashcan: Blockly.Trashcan;
/**
* This workspace's scrollbars, if they exist.
* @type {Blockly.ScrollbarPair}
*/
scrollbar: Blockly.ScrollbarPair;
/**
* Developers may define this function to add custom menu options to the
* workspace's context menu or edit the workspace-created set of menu options.
* @param {!Array<!Object>} options List of menu options to add to.
* @param {!Event} e The right-click event that triggered the context menu.
*/
configureContextMenu(options: Object[], e: Event): void;
/**
* In a flyout, the target workspace where blocks should be placed after a drag.
* Otherwise null.
* @type {Blockly.WorkspaceSvg}
* @package
*/
targetWorkspace: Blockly.WorkspaceSvg;
/**
* Get the marker manager for this workspace.
* @return {!Blockly.MarkerManager} The marker manager.
*/
getMarkerManager(): Blockly.MarkerManager;
/**
* Gets the metrics manager for this workspace.
* @return {!Blockly.IMetricsManager} The metrics manager.
* @public
*/
getMetricsManager(): Blockly.IMetricsManager;
/**
* Sets the metrics manager for the workspace.
* @param {!Blockly.IMetricsManager} metricsManager The metrics manager.
* @package
*/
setMetricsManager(metricsManager: Blockly.IMetricsManager): void;
/**
* Gets the component manager for this workspace.
* @return {!Blockly.ComponentManager} The component manager.
* @public
*/
getComponentManager(): Blockly.ComponentManager;
/**
* Add the cursor SVG to this workspaces SVG group.
* @param {SVGElement} cursorSvg The SVG root of the cursor to be added to the
* workspace SVG group.
* @package
*/
setCursorSvg(cursorSvg: SVGElement): void;
/**
* Add the marker SVG to this workspaces SVG group.
* @param {SVGElement} markerSvg The SVG root of the marker to be added to the
* workspace SVG group.
* @package
*/
setMarkerSvg(markerSvg: SVGElement): void;
/**
* Get the marker with the given ID.
* @param {string} id The ID of the marker.
* @return {?Blockly.Marker} The marker with the given ID or null if no marker
* with the given ID exists.
* @package
*/
getMarker(id: string): Blockly.Marker;
/**
* The cursor for this workspace.
* @return {?Blockly.Cursor} The cursor for the workspace.
*/
getCursor(): Blockly.Cursor;
/**
* Get the block renderer attached to this workspace.
* @return {!Blockly.blockRendering.Renderer} The renderer attached to this
* workspace.
*/
getRenderer(): Blockly.blockRendering.Renderer;
/**
* Get the theme manager for this workspace.
* @return {!Blockly.ThemeManager} The theme manager for this workspace.
* @package
*/
getThemeManager(): Blockly.ThemeManager;
/**
* Get the workspace theme object.
* @return {!Blockly.Theme} The workspace theme object.
*/
getTheme(): Blockly.Theme;
/**
* Set the workspace theme object.
* If no theme is passed, default to the `Blockly.Themes.Classic` theme.
* @param {Blockly.Theme} theme The workspace theme object.
*/
setTheme(theme: Blockly.Theme): void;
/**
* Refresh all blocks on the workspace after a theme update.
* @package
*/
refreshTheme(): void;
/**
* Getter for the inverted screen CTM.
* @return {?SVGMatrix} The matrix to use in mouseToSvg
*/
getInverseScreenCTM(): SVGMatrix;
/**
* Mark the inverse screen CTM as dirty.
*/
updateInverseScreenCTM(): void;
/**
* Getter for isVisible
* @return {boolean} Whether the workspace is visible.
* False if the workspace has been hidden by calling `setVisible(false)`.
*/
isVisible(): boolean;
/**
* Return the absolute coordinates of the top-left corner of this element,
* scales that after canvas SVG element, if it's a descendant.
* The origin (0,0) is the top-left corner of the Blockly SVG.
* @param {!SVGElement} element SVG element to find the coordinates of.
* @return {!Blockly.utils.Coordinate} Object with .x and .y properties.
* @package
*/
getSvgXY(element: SVGElement): Blockly.utils.Coordinate;
/**
* Gets the size of the workspace's parent SVG element.
* @return {!Blockly.utils.Size} The cached width and height of the workspace's
* parent SVG element.
* @package
*/
getCachedParentSvgSize(): Blockly.utils.Size;
/**
* Return the position of the workspace origin relative to the injection div
* origin in pixels.
* The workspace origin is where a block would render at position (0, 0).
* It is not the upper left corner of the workspace SVG.
* @return {!Blockly.utils.Coordinate} Offset in pixels.
* @package
*/
getOriginOffsetInPixels(): Blockly.utils.Coordinate;
/**
* Return the injection div that is a parent of this workspace.
* Walks the DOM the first time it's called, then returns a cached value.
* Note: We assume this is only called after the workspace has been injected
* into the DOM.
* @return {!Element} The first parent div with 'injectionDiv' in the name.
* @package
*/
getInjectionDiv(): Element;
/**
* Get the SVG block canvas for the workspace.
* @return {?SVGElement} The SVG group for the workspace.
* @package
*/
getBlockCanvas(): SVGElement;
/**
* Save resize handler data so we can delete it later in dispose.
* @param {!Blockly.browserEvents.Data} handler Data that can be passed to
* eventHandling.unbind.
*/
setResizeHandlerWrapper(handler: Blockly.browserEvents.Data): void;
/**
* Create the workspace DOM elements.
* @param {string=} opt_backgroundClass Either 'blocklyMainBackground' or
* 'blocklyMutatorBackground'.
* @return {!Element} The workspace's SVG group.
*/
createDom(opt_backgroundClass?: string): Element;
/**
* <g class="blocklyWorkspace">
* <rect class="blocklyMainBackground" height="100%" width="100%"></rect>
* [Trashcan and/or flyout may go here]
* <g class="blocklyBlockCanvas"></g>
* <g class="blocklyBubbleCanvas"></g>
* </g>
* @type {SVGElement}
*/
svgGroup_: SVGElement;
/** @type {SVGElement} */
svgBackground_: SVGElement;
/** @type {SVGElement} */
svgBlockCanvas_: SVGElement;
/** @type {SVGElement} */
svgBubbleCanvas_: SVGElement;
/**
* Dispose of this workspace.
* Unlink from all DOM elements to prevent memory leaks.
* @suppress {checkTypes}
*/
dispose(): void;
/**
* Add a trashcan.
* @package
*/
addTrashcan(): void;
/**
* Add zoom controls.
* @package
*/
addZoomControls(): void;
/** @type {Blockly.ZoomControls} */
zoomControls_: Blockly.ZoomControls;
/**
* Add a flyout element in an element with the given tag name.
* @param {string|
* !Blockly.utils.Svg<!SVGSVGElement>|
* !Blockly.utils.Svg<!SVGGElement>} tagName What type of tag the
* flyout belongs in.
* @return {!Element} The element containing the flyout DOM.
* @package
*/
addFlyout(tagName: string|Blockly.utils.Svg<SVGSVGElement>|Blockly.utils.Svg<SVGGElement>): Element;
/**
* Getter for the flyout associated with this workspace. This flyout may be
* owned by either the toolbox or the workspace, depending on toolbox
* configuration. It will be null if there is no flyout.
* @param {boolean=} opt_own Whether to only return the workspace's own flyout.
* @return {?Blockly.IFlyout} The flyout on this workspace.
* @package
*/
getFlyout(opt_own?: boolean): Blockly.IFlyout;
/**
* Getter for the toolbox associated with this workspace, if one exists.
* @return {?Blockly.IToolbox} The toolbox on this workspace.
* @package
*/
getToolbox(): Blockly.IToolbox;
/**
* If enabled, resize the parts of the workspace that change when the workspace
* contents (e.g. block positions) change. This will also scroll the
* workspace contents if needed.
* @package
*/
resizeContents(): void;
/**
* Resize and reposition all of the workspace chrome (toolbox,
* trash, scrollbars etc.)
* This should be called when something changes that
* requires recalculating dimensions and positions of the
* trash, zoom, toolbox, etc. (e.g. window resize).
*/
resize(): void;
/**
* Resizes and repositions workspace chrome if the page has a new
* scroll position.
* @package
*/
updateScreenCalculationsIfScrolled(): void;
/**
* Get the SVG element that forms the drawing surface.
* @return {!SVGGElement} SVG group element.
*/
getCanvas(): SVGGElement;
/**
* Caches the width and height of the workspace's parent SVG element for use
* with getSvgMetrics.
* @param {?number} width The width of the parent SVG element.
* @param {?number} height The height of the parent SVG element
* @package
*/
setCachedParentSvgSize(width: number, height: number): void;
/**
* Get the SVG element that forms the bubble surface.
* @return {!SVGGElement} SVG group element.
*/
getBubbleCanvas(): SVGGElement;
/**
* Get the SVG element that contains this workspace.
* Note: We assume this is only called after the workspace has been injected
* into the DOM.
* @return {!SVGElement} SVG element.
*/
getParentSvg(): SVGElement;
/**
* Fires a viewport event if events are enabled and there is a change in
* viewport values.
* @package
*/
maybeFireViewportChangeEvent(): void;
/**
* Translate this workspace to new coordinates.
* @param {number} x Horizontal translation, in pixel units relative to the
* top left of the Blockly div.
* @param {number} y Vertical translation, in pixel units relative to the
* top left of the Blockly div.
*/
translate(x: number, y: number): void;
/**
* Called at the end of a workspace drag to take the contents
* out of the drag surface and put them back into the workspace SVG.
* Does nothing if the workspace drag surface is not enabled.
* @package
*/
resetDragSurface(): void;
/**
* Called at the beginning of a workspace drag to move contents of
* the workspace to the drag surface.
* Does nothing if the drag surface is not enabled.
* @package
*/
setupDragSurface(): void;
/**
* Gets the drag surface blocks are moved to when a drag is started.
* @return {?Blockly.BlockDragSurfaceSvg} This workspace's block drag surface,
* if one is in use.
* @package
*/
getBlockDragSurface(): Blockly.BlockDragSurfaceSvg;
/**
* Returns the horizontal offset of the workspace.
* Intended for LTR/RTL compatibility in XML.
* @return {number} Width.
*/
getWidth(): number;
/**
* Toggles the visibility of the workspace.
* Currently only intended for main workspace.
* @param {boolean} isVisible True if workspace should be visible.
*/
setVisible(isVisible: boolean): void;
/**
* Render all blocks in workspace.
*/
render(): void;
/**
* Highlight or unhighlight a block in the workspace. Block highlighting is
* often used to visually mark blocks currently being executed.
* @param {?string} id ID of block to highlight/unhighlight,
* or null for no block (used to unhighlight all blocks).
* @param {boolean=} opt_state If undefined, highlight specified block and
* automatically unhighlight all others. If true or false, manually
* highlight/unhighlight the specified block.
*/
highlightBlock(id: string, opt_state?: boolean): void;
/**
* Paste the provided block onto the workspace.
* @param {!Element|!DocumentFragment} xmlBlock XML block element or an empty
* DocumentFragment if the block was an insertion marker.
*/
paste(xmlBlock: Element|DocumentFragment): void;
/**
* Refresh the toolbox unless there's a drag in progress.
* @package
*/
refreshToolboxSelection(): void;
/**
* Rename a variable by updating its name in the variable map. Update the
* flyout to show the renamed variable immediately.
* @param {string} id ID of the variable to rename.
* @param {string} newName New variable name.
*/
renameVariableById(id: string, newName: string): void;
/**
* Delete a variable by the passed in ID. Update the flyout to show
* immediately that the variable is deleted.
* @param {string} id ID of variable to delete.
*/
deleteVariableById(id: string): void;
/**
* Create a new variable with the given name. Update the flyout to show the
* new variable immediately.
* @param {string} name The new variable's name.
* @param {?string=} opt_type The type of the variable like 'int' or 'string'.
* Does not need to be unique. Field_variable can filter variables based on
* their type. This will default to '' which is a specific type.
* @param {?string=} opt_id The unique ID of the variable. This will default to
* a UUID.
* @return {!Blockly.VariableModel} The newly created variable.
*/
createVariable(name: string, opt_type?: string, opt_id?: string): Blockly.VariableModel;
/**
* Make a list of all the delete areas for this workspace.
* @deprecated Use workspace.recordDragTargets. (2021 June)
*/
recordDeleteAreas(): void;
/**
* Make a list of all the delete areas for this workspace.
*/
recordDragTargets(): void;
/**
* Returns the drag target the mouse event is over.
* @param {!Event} e Mouse move event.
* @return {?Blockly.IDragTarget} Null if not over a drag target, or the drag
* target the event is over.
*/
getDragTarget(e: Event): Blockly.IDragTarget;
/**
* Start tracking a drag of an object on this workspace.
* @param {!Event} e Mouse down event.
* @param {!Blockly.utils.Coordinate} xy Starting location of object.
*/
startDrag(e: Event, xy: Blockly.utils.Coordinate): void;
/**
* Track a drag of an object on this workspace.
* @param {!Event} e Mouse move event.
* @return {!Blockly.utils.Coordinate} New location of object.
*/
moveDrag(e: Event): Blockly.utils.Coordinate;
/**
* Is the user currently dragging a block or scrolling the flyout/workspace?
* @return {boolean} True if currently dragging or scrolling.
*/
isDragging(): boolean;
/**
* Is this workspace draggable?
* @return {boolean} True if this workspace may be dragged.
*/
isDraggable(): boolean;
/**
* Is this workspace movable?
*
* This means the user can reposition the X Y coordinates of the workspace
* through input. This can be through scrollbars, scroll wheel, dragging, or
* through zooming with the scroll wheel or pinch (since the zoom is centered on
* the mouse position). This does not include zooming with the zoom controls
* since the X Y coordinates are decided programmatically.
* @return {boolean} True if the workspace is movable, false otherwise.
*/
isMovable(): boolean;
/**
* Is this workspace movable horizontally?
* @return {boolean} True if the workspace is movable horizontally, false
* otherwise.
*/
isMovableHorizontally(): boolean;
/**
* Is this workspace movable vertically?
* @return {boolean} True if the workspace is movable vertically, false
* otherwise.
*/
isMovableVertically(): boolean;
/**
* Calculate the bounding box for the blocks on the workspace.
* Coordinate system: workspace coordinates.
*
* @return {!Blockly.utils.Rect} Contains the position and size of the
* bounding box containing the blocks on the workspace.
*/
getBlocksBoundingBox(): Blockly.utils.Rect;
/**
* Clean up the workspace by ordering all the blocks in a column.
*/
cleanUp(): void;
/**
* Show the context menu for the workspace.
* @param {!Event} e Mouse event.
* @package
*/
showContextMenu(e: Event): void;
/**
* Modify the block tree on the existing toolbox.
* @param {?Blockly.utils.toolbox.ToolboxDefinition} toolboxDef
* DOM tree of toolbox contents, string of toolbox contents, or JSON
* representing toolbox definition.
*/
updateToolbox(toolboxDef: Blockly.utils.toolbox.ToolboxDefinition): void;
/**
* Mark this workspace as the currently focused main workspace.
*/
markFocused(): void;
/**
* Zooms the workspace in or out relative to/centered on the given (x, y)
* coordinate.
* @param {number} x X coordinate of center, in pixel units relative to the
* top-left corner of the parentSVG.
* @param {number} y Y coordinate of center, in pixel units relative to the
* top-left corner of the parentSVG.
* @param {number} amount Amount of zooming. The formula for the new scale
* is newScale = currentScale * (scaleSpeed^amount). scaleSpeed is set in
* the workspace options. Negative amount values zoom out, and positive
* amount values zoom in.
*/
zoom(x: number, y: number, amount: number): void;
/**
* Zooming the blocks centered in the center of view with zooming in or out.
* @param {number} type Type of zooming (-1 zooming out and 1 zooming in).
*/
zoomCenter(type: number): void;
/**
* Zoom the blocks to fit in the workspace if possible.
*/
zoomToFit(): void;
/**
* Add a transition class to the block and bubble canvas, to animate any
* transform changes.
* @package
*/
beginCanvasTransition(): void;
/**
* Remove transition class from the block and bubble canvas.
* @package
*/
endCanvasTransition(): void;
/**
* Center the workspace.
*/
scrollCenter(): void;
/**
* Scroll the workspace to center on the given block.
* @param {?string} id ID of block center on.
* @public
*/
centerOnBlock(id: string): void;
/**
* Set the workspace's zoom factor.
* @param {number} newScale Zoom factor. Units: (pixels / workspaceUnit).
*/
setScale(newScale: number): void;
/**
* Get the workspace's zoom factor. If the workspace has a parent, we call into
* the parent to get the workspace scale.
* @return {number} The workspace zoom factor. Units: (pixels / workspaceUnit).
*/
getScale(): number;
/**
* Scroll the workspace to a specified offset (in pixels), keeping in the
* workspace bounds. See comment on workspaceSvg.scrollX for more detail on
* the meaning of these values.
* @param {number} x Target X to scroll to.
* @param {number} y Target Y to scroll to.
* @package
*/
scroll(x: number, y: number): void;
/**
* Adds a block to the list of top blocks.
* @param {!Blockly.Block} block Block to add.
*/
addTopBlock(block: Blockly.Block): void;
/**
* Removes a block from the list of top blocks.
* @param {!Blockly.Block} block Block to remove.
*/
removeTopBlock(block: Blockly.Block): void;
/**
* Adds a comment to the list of top comments.
* @param {!Blockly.WorkspaceComment} comment comment to add.
*/
addTopComment(comment: Blockly.WorkspaceComment): void;
/**
* Removes a comment from the list of top comments.
* @param {!Blockly.WorkspaceComment} comment comment to remove.
*/
removeTopComment(comment: Blockly.WorkspaceComment): void;
/**
* Adds a bounded element to the list of top bounded elements.
* @param {!Blockly.IBoundedElement} element Bounded element to add.
*/
addTopBoundedElement(element: Blockly.IBoundedElement): void;
/**
* Removes a bounded element from the list of top bounded elements.
* @param {!Blockly.IBoundedElement} element Bounded element to remove.
*/
removeTopBoundedElement(element: Blockly.IBoundedElement): void;
/**
* Finds the top-level bounded elements and returns them.
* @return {!Array<!Blockly.IBoundedElement>} The top-level bounded elements.
*/
getTopBoundedElements(): Blockly.IBoundedElement[];
/**
* Update whether this workspace has resizes enabled.
* If enabled, workspace will resize when appropriate.
* If disabled, workspace will not resize until re-enabled.
* Use to avoid resizing during a batch operation, for performance.
* @param {boolean} enabled Whether resizes should be enabled.
*/
setResizesEnabled(enabled: boolean): void;
/**
* Dispose of all blocks in workspace, with an optimization to prevent resizes.
*/
clear(): void;
/**
* Register a callback function associated with a given key, for clicks on
* buttons and labels in the flyout.
* For instance, a button specified by the XML
* <button text="create variable" callbackKey="CREATE_VARIABLE"></button>
* should be matched by a call to
* registerButtonCallback("CREATE_VARIABLE", yourCallbackFunction).
* @param {string} key The name to use to look up this function.
* @param {function(!Blockly.FlyoutButton)} func The function to call when the
* given button is clicked.
*/
registerButtonCallback(key: string, func: { (_0: Blockly.FlyoutButton): any /*missing*/ }): void;
/**
* Get the callback function associated with a given key, for clicks on buttons
* and labels in the flyout.
* @param {string} key The name to use to look up the function.
* @return {?function(!Blockly.FlyoutButton)} The function corresponding to the
* given key for this workspace; null if no callback is registered.
*/
getButtonCallback(key: string): { (_0: Blockly.FlyoutButton): any /*missing*/ };
/**
* Remove a callback for a click on a button in the flyout.
* @param {string} key The name associated with the callback function.
*/
removeButtonCallback(key: string): void;
/**
* Register a callback function associated with a given key, for populating
* custom toolbox categories in this workspace. See the variable and procedure
* categories as an example.
* @param {string} key The name to use to look up this function.
* @param {function(!Blockly.Workspace):!Array<!Element>} func The function to
* call when the given toolbox category is opened.
*/
registerToolboxCategoryCallback(key: string, func: { (_0: Blockly.Workspace): Element[] }): void;
/**
* Get the callback function associated with a given key, for populating
* custom toolbox categories in this workspace.
* @param {string} key The name to use to look up the function.
* @return {?function(!Blockly.Workspace):!Array<!Element>} The function
* corresponding to the given key for this workspace, or null if no function
* is registered.
*/
getToolboxCategoryCallback(key: string): { (_0: Blockly.Workspace): Element[] };
/**
* Remove a callback for a click on a custom category's name in the toolbox.
* @param {string} key The name associated with the callback function.
*/
removeToolboxCategoryCallback(key: string): void;
/**
* Look up the gesture that is tracking this touch stream on this workspace.
* May create a new gesture.
* @param {!Event} e Mouse event or touch event.
* @return {?Blockly.TouchGesture} The gesture that is tracking this touch
* stream, or null if no valid gesture exists.
* @package
*/
getGesture(e: Event): Blockly.TouchGesture;
/**
* Clear the reference to the current gesture.
* @package
*/
clearGesture(): void;
/**
* Cancel the current gesture, if one exists.
* @package
*/
cancelCurrentGesture(): void;
/**
* Get the audio manager for this workspace.
* @return {!Blockly.WorkspaceAudio} The audio manager for this workspace.
*/
getAudioManager(): Blockly.WorkspaceAudio;
/**
* Get the grid object for this workspace, or null if there is none.
* @return {?Blockly.Grid} The grid object for this workspace.
* @package
*/
getGrid(): Blockly.Grid;
}
}
declare module Blockly.Xml {
/**
* Encode a block tree as XML.
* @param {!Blockly.Workspace} workspace The workspace containing blocks.
* @param {boolean=} opt_noId True if the encoder should skip the block IDs.
* @return {!Element} XML DOM element.
*/
function workspaceToDom(workspace: Blockly.Workspace, opt_noId?: boolean): Element;
/**
* Encode a list of variables as XML.
* @param {!Array<!Blockly.VariableModel>} variableList List of all variable
* models.
* @return {!Element} Tree of XML elements.
*/
function variablesToDom(variableList: Blockly.VariableModel[]): Element;
/**
* Encode a block subtree as XML with XY coordinates.
* @param {!Blockly.Block} block The root block to encode.
* @param {boolean=} opt_noId True if the encoder should skip the block ID.
* @return {!Element|!DocumentFragment} Tree of XML elements or an empty document
* fragment if the block was an insertion marker.
*/
function blockToDomWithXY(block: Blockly.Block, opt_noId?: boolean): Element|DocumentFragment;
/**
* Encode a block subtree as XML.
* @param {!Blockly.Block} block The root block to encode.
* @param {boolean=} opt_noId True if the encoder should skip the block ID.
* @return {!Element|!DocumentFragment} Tree of XML elements or an empty document
* fragment if the block was an insertion marker.
*/
function blockToDom(block: Blockly.Block, opt_noId?: boolean): Element|DocumentFragment;
/**
* Converts a DOM structure into plain text.
* Currently the text format is fairly ugly: all one line with no whitespace,
* unless the DOM itself has whitespace built-in.
* @param {!Node} dom A tree of XML nodes.
* @return {string} Text representation.
*/
function domToText(dom: Node): string;
/**
* Converts a DOM structure into properly indented text.
* @param {!Node} dom A tree of XML elements.
* @return {string} Text representation.
*/
function domToPrettyText(dom: Node): string;
/**
* Converts an XML string into a DOM structure.
* @param {string} text An XML string.
* @return {!Element} A DOM object representing the singular child of the
* document element.
* @throws if the text doesn't parse.
*/
function textToDom(text: string): Element;
/**
* Clear the given workspace then decode an XML DOM and
* create blocks on the workspace.
* @param {!Element} xml XML DOM.
* @param {!Blockly.Workspace} workspace The workspace.
* @return {!Array<string>} An array containing new block IDs.
*/
function clearWorkspaceAndLoadFromXml(xml: Element, workspace: Blockly.Workspace): string[];
/**
* Decode an XML DOM and create blocks on the workspace.
* @param {!Element} xml XML DOM.
* @param {!Blockly.Workspace} workspace The workspace.
* @return {!Array<string>} An array containing new block IDs.
* @suppress {strictModuleDepCheck} Suppress module check while workspace
* comments are not bundled in.
*/
function domToWorkspace(xml: Element, workspace: Blockly.Workspace): string[];
/**
* Decode an XML DOM and create blocks on the workspace. Position the new
* blocks immediately below prior blocks, aligned by their starting edge.
* @param {!Element} xml The XML DOM.
* @param {!Blockly.Workspace} workspace The workspace to add to.
* @return {!Array<string>} An array containing new block IDs.
*/
function appendDomToWorkspace(xml: Element, workspace: Blockly.Workspace): string[];
/**
* Decode an XML block tag and create a block (and possibly sub blocks) on the
* workspace.
* @param {!Element} xmlBlock XML block element.
* @param {!Blockly.Workspace} workspace The workspace.
* @return {!Blockly.Block} The root block created.
*/
function domToBlock(xmlBlock: Element, workspace: Blockly.Workspace): Blockly.Block;
/**
* Decode an XML list of variables and add the variables to the workspace.
* @param {!Element} xmlVariables List of XML variable elements.
* @param {!Blockly.Workspace} workspace The workspace to which the variable
* should be added.
*/
function domToVariables(xmlVariables: Element, workspace: Blockly.Workspace): void;
/**
* A mapping of nodeName to node for child nodes of xmlBlock.
* @typedef {{
* mutation: !Array<!Element>,
* comment: !Array<!Element>,
* data: !Array<!Element>,
* field: !Array<!Element>,
* input: !Array<!Element>,
* next: !Array<!Element>
* }}
*/
interface childNodeTagMap {
mutation: Element[];
comment: Element[];
data: Element[];
field: Element[];
input: Element[];
next: Element[]
}
/**
* Creates a mapping of childNodes for each supported XML tag for the provided
* xmlBlock. Logs a warning for any encountered unsupported tags.
* @param {!Element} xmlBlock XML block element.
* @return {!Blockly.Xml.childNodeTagMap} The childNode map from nodeName to
* node.
*/
function mapSupportedXmlTags_(xmlBlock: Element): Blockly.Xml.childNodeTagMap;
/**
* Remove any 'next' block (statements in a stack).
* @param {!Element|!DocumentFragment} xmlBlock XML block element or an empty
* DocumentFragment if the block was an insertion marker.
*/
function deleteNext(xmlBlock: Element|DocumentFragment): void;
}
declare module Blockly {
class ZoomControls extends ZoomControls__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class ZoomControls__Class implements Blockly.IPositionable {
/**
* Class for a zoom controls.
* @param {!Blockly.WorkspaceSvg} workspace The workspace to sit in.
* @constructor
* @implements {Blockly.IPositionable}
*/
constructor(workspace: Blockly.WorkspaceSvg);
/**
* The unique id for this component that is used to register with the
* ComponentManager.
* @type {string}
*/
id: string;
/**
* Create the zoom controls.
* @return {!SVGElement} The zoom controls SVG group.
*/
createDom(): SVGElement;
/**
* Initializes the zoom controls.
*/
init(): void;
/**
* Disposes of this zoom controls.
* Unlink from all DOM elements to prevent memory leaks.
*/
dispose(): void;
/**
* Returns the bounding rectangle of the UI element in pixel units relative to
* the Blockly injection div.
* @return {?Blockly.utils.Rect} The UI elements’s bounding box. Null if
* bounding box should be ignored by other UI elements.
*/
getBoundingRectangle(): Blockly.utils.Rect;
/**
* Positions the zoom controls.
* It is positioned in the opposite corner to the corner the
* categories/toolbox starts at.
* @param {!Blockly.MetricsManager.UiMetrics} metrics The workspace metrics.
* @param {!Array<!Blockly.utils.Rect>} savedPositions List of rectangles that
* are already on the workspace.
*/
position(metrics: Blockly.MetricsManager.UiMetrics, savedPositions: Blockly.utils.Rect[]): void;
}
}
declare module Blockly.Events {
class BlockBase extends BlockBase__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class BlockBase__Class extends Blockly.Events.Abstract__Class {
/**
* Abstract class for a block event.
* @param {!Blockly.Block=} opt_block The block this event corresponds to.
* Undefined for a blank event.
* @extends {Blockly.Events.Abstract}
* @constructor
*/
constructor(opt_block?: Blockly.Block);
/**
* The block ID for the block this event pertains to
* @type {string}
*/
blockId: string;
/**
* The workspace identifier for this event.
* @type {string}
*/
workspaceId: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
}
class BlockChange extends BlockChange__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class BlockChange__Class extends Blockly.Events.BlockBase__Class {
/**
* Class for a block change event.
* @param {!Blockly.Block=} opt_block The changed block. Undefined for a blank
* event.
* @param {string=} opt_element One of 'field', 'comment', 'disabled', etc.
* @param {?string=} opt_name Name of input or field affected, or null.
* @param {*=} opt_oldValue Previous value of element.
* @param {*=} opt_newValue New value of element.
* @extends {Blockly.Events.BlockBase}
* @constructor
*/
constructor(opt_block?: Blockly.Block, opt_element?: string, opt_name?: string, opt_oldValue?: any, opt_newValue?: any);
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
/**
* Does this event record any change of state?
* @return {boolean} False if something changed.
*/
isNull(): boolean;
/**
* Run a change event.
* @param {boolean} forward True if run forward, false if run backward (undo).
*/
run(forward: boolean): void;
}
class Change extends Change__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Change__Class extends Blockly.Events.BlockBase__Class {
/**
* Class for a block change event.
* @param {!Blockly.Block=} opt_block The changed block. Undefined for a blank
* event.
* @param {string=} opt_element One of 'field', 'comment', 'disabled', etc.
* @param {?string=} opt_name Name of input or field affected, or null.
* @param {*=} opt_oldValue Previous value of element.
* @param {*=} opt_newValue New value of element.
* @extends {Blockly.Events.BlockBase}
* @constructor
*/
constructor(opt_block?: Blockly.Block, opt_element?: string, opt_name?: string, opt_oldValue?: any, opt_newValue?: any);
}
class Create extends Create__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Create__Class extends Blockly.Events.BlockBase__Class {
/**
* Class for a block creation event.
* @param {!Blockly.Block=} opt_block The created block. Undefined for a blank
* event.
* @extends {Blockly.Events.BlockBase}
* @constructor
*/
constructor(opt_block?: Blockly.Block);
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
/**
* Run a creation event.
* @param {boolean} forward True if run forward, false if run backward (undo).
*/
run(forward: boolean): void;
}
class BlockCreate extends BlockCreate__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class BlockCreate__Class extends Blockly.Events.BlockBase__Class {
/**
* Class for a block creation event.
* @param {!Blockly.Block=} block The created block. Undefined for a blank
* event.
* @extends {Blockly.Events.BlockBase}
* @constructor
*/
constructor(block?: Blockly.Block);
}
class Delete extends Delete__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Delete__Class extends Blockly.Events.BlockBase__Class {
/**
* Class for a block deletion event.
* @param {!Blockly.Block=} opt_block The deleted block. Undefined for a blank
* event.
* @extends {Blockly.Events.BlockBase}
* @constructor
*/
constructor(opt_block?: Blockly.Block);
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
/**
* Run a deletion event.
* @param {boolean} forward True if run forward, false if run backward (undo).
*/
run(forward: boolean): void;
}
class BlockDelete extends BlockDelete__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class BlockDelete__Class extends Blockly.Events.BlockBase__Class {
/**
* Class for a block deletion event.
* @param {?Blockly.Block} block The deleted block. Null for a blank event.
* @extends {Blockly.Events.BlockBase}
* @constructor
*/
constructor(block: Blockly.Block);
}
class Move extends Move__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Move__Class extends Blockly.Events.BlockBase__Class {
/**
* Class for a block move event. Created before the move.
* @param {!Blockly.Block=} opt_block The moved block. Undefined for a blank
* event.
* @extends {Blockly.Events.BlockBase}
* @constructor
*/
constructor(opt_block?: Blockly.Block);
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
/**
* Record the block's new location. Called after the move.
*/
recordNew(): void;
/**
* Does this event record any change of state?
* @return {boolean} False if something changed.
*/
isNull(): boolean;
/**
* Run a move event.
* @param {boolean} forward True if run forward, false if run backward (undo).
*/
run(forward: boolean): void;
}
class BlockMove extends BlockMove__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class BlockMove__Class extends Blockly.Events.BlockBase__Class {
/**
* Class for a block move event. Created before the move.
* @param {?Blockly.Block} block The moved block. Null for a blank event.
* @extends {Blockly.Events.BlockBase}
* @constructor
*/
constructor(block: Blockly.Block);
}
}
declare module Blockly.Events {
/**
* Sets whether the next event should be added to the undo stack.
* @type {boolean}
*/
var recordUndo: boolean;
/**
* Name of event that creates a block. Will be deprecated for BLOCK_CREATE.
* @const
*/
var CREATE: any /*missing*/;
/**
* Name of event that creates a block.
* @const
*/
var BLOCK_CREATE: any /*missing*/;
/**
* Name of event that deletes a block. Will be deprecated for BLOCK_DELETE.
* @const
*/
var DELETE: any /*missing*/;
/**
* Name of event that deletes a block.
* @const
*/
var BLOCK_DELETE: any /*missing*/;
/**
* Name of event that changes a block. Will be deprecated for BLOCK_CHANGE.
* @const
*/
var CHANGE: any /*missing*/;
/**
* Name of event that changes a block.
* @const
*/
var BLOCK_CHANGE: any /*missing*/;
/**
* Name of event that moves a block. Will be deprecated for BLOCK_MOVE.
* @const
*/
var MOVE: any /*missing*/;
/**
* Name of event that moves a block.
* @const
*/
var BLOCK_MOVE: any /*missing*/;
/**
* Name of event that creates a variable.
* @const
*/
var VAR_CREATE: any /*missing*/;
/**
* Name of event that deletes a variable.
* @const
*/
var VAR_DELETE: any /*missing*/;
/**
* Name of event that renames a variable.
* @const
*/
var VAR_RENAME: any /*missing*/;
/**
* Name of generic event that records a UI change.
* @const
*/
var UI: any /*missing*/;
/**
* Name of event that record a block drags a block.
* @const
*/
var BLOCK_DRAG: any /*missing*/;
/**
* Name of event that records a change in selected element.
* @const
*/
var SELECTED: any /*missing*/;
/**
* Name of event that records a click.
* @const
*/
var CLICK: any /*missing*/;
/**
* Name of event that records a marker move.
* @const
*/
var MARKER_MOVE: any /*missing*/;
/**
* Name of event that records a bubble open.
* @const
*/
var BUBBLE_OPEN: any /*missing*/;
/**
* Name of event that records a trashcan open.
* @const
*/
var TRASHCAN_OPEN: any /*missing*/;
/**
* Name of event that records a toolbox item select.
* @const
*/
var TOOLBOX_ITEM_SELECT: any /*missing*/;
/**
* Name of event that records a theme change.
* @const
*/
var THEME_CHANGE: any /*missing*/;
/**
* Name of event that records a viewport change.
* @const
*/
var VIEWPORT_CHANGE: any /*missing*/;
/**
* Name of event that creates a comment.
* @const
*/
var COMMENT_CREATE: any /*missing*/;
/**
* Name of event that deletes a comment.
* @const
*/
var COMMENT_DELETE: any /*missing*/;
/**
* Name of event that changes a comment.
* @const
*/
var COMMENT_CHANGE: any /*missing*/;
/**
* Name of event that moves a comment.
* @const
*/
var COMMENT_MOVE: any /*missing*/;
/**
* Name of event that records a workspace load.
*/
var FINISHED_LOADING: any /*missing*/;
/**
* Type of events that cause objects to be bumped back into the visible
* portion of the workspace.
*
* Not to be confused with bumping so that disconnected connections do not
* appear connected.
* @typedef {!Blockly.Events.BlockCreate|!Blockly.Events.BlockMove|
* !Blockly.Events.CommentCreate|!Blockly.Events.CommentMove}
*/
type BumpEvent = Blockly.Events.BlockCreate|Blockly.Events.BlockMove|Blockly.Events.CommentCreate|Blockly.Events.CommentMove;
/**
* List of events that cause objects to be bumped back into the visible
* portion of the workspace.
*
* Not to be confused with bumping so that disconnected connections do not
* appear connected.
* @const
*/
var BUMP_EVENTS: any /*missing*/;
/**
* Create a custom event and fire it.
* @param {!Blockly.Events.Abstract} event Custom data for event.
*/
function fire(event: Blockly.Events.Abstract): void;
/**
* Filter the queued events and merge duplicates.
* @param {!Array<!Blockly.Events.Abstract>} queueIn Array of events.
* @param {boolean} forward True if forward (redo), false if backward (undo).
* @return {!Array<!Blockly.Events.Abstract>} Array of filtered events.
*/
function filter(queueIn: Blockly.Events.Abstract[], forward: boolean): Blockly.Events.Abstract[];
/**
* Modify pending undo events so that when they are fired they don't land
* in the undo stack. Called by Blockly.Workspace.clearUndo.
*/
function clearPendingUndo(): void;
/**
* Stop sending events. Every call to this function MUST also call enable.
*/
function disable(): void;
/**
* Start sending events. Unless events were already disabled when the
* corresponding call to disable was made.
*/
function enable(): void;
/**
* Returns whether events may be fired or not.
* @return {boolean} True if enabled.
*/
function isEnabled(): boolean;
/**
* Current group.
* @return {string} ID string.
*/
function getGroup(): string;
/**
* Start or stop a group.
* @param {boolean|string} state True to start new group, false to end group.
* String to set group explicitly.
*/
function setGroup(state: boolean|string): void;
/**
* Compute a list of the IDs of the specified block and all its descendants.
* @param {!Blockly.Block} block The root block.
* @return {!Array<string>} List of block IDs.
* @package
*/
function getDescendantIds(block: Blockly.Block): string[];
/**
* Decode the JSON into an event.
* @param {!Object} json JSON representation.
* @param {!Blockly.Workspace} workspace Target workspace for event.
* @return {!Blockly.Events.Abstract} The event represented by the JSON.
* @throws {Error} if an event type is not found in the registry.
*/
function fromJson(json: Object, workspace: Blockly.Workspace): Blockly.Events.Abstract;
/**
* Gets the class for a specific event type from the registry.
* @param {string} eventType The type of the event to get.
* @return {?function(new:Blockly.Events.Abstract, ...?)} The event class with
* the given type or null if none exists.
*/
function get(eventType: string): { (_0: any[]): any /*missing*/ };
/**
* Enable/disable a block depending on whether it is properly connected.
* Use this on applications where all blocks should be connected to a top block.
* Recommend setting the 'disable' option to 'false' in the config so that
* users don't try to re-enable disabled orphan blocks.
* @param {!Blockly.Events.Abstract} event Custom data for event.
*/
function disableOrphans(event: Blockly.Events.Abstract): void;
}
declare module Blockly.Events {
class Abstract extends Abstract__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Abstract__Class {
/**
* Abstract class for an event.
* @constructor
*/
constructor();
/**
* Whether or not the event is blank (to be populated by fromJson).
* @type {?boolean}
*/
isBlank: boolean;
/**
* The workspace identifier for this event.
* @type {string|undefined}
*/
workspaceId: string|any /*undefined*/;
/**
* The event group id for the group this event belongs to. Groups define
* events that should be treated as an single action from the user's
* perspective, and should be undone together.
* @type {string}
*/
group: string;
/**
* Sets whether the event should be added to the undo stack.
* @type {boolean}
*/
recordUndo: boolean;
/**
* Whether or not the event is a UI event.
* @type {boolean}
*/
isUiEvent: boolean;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
/**
* Does this event record any change of state?
* @return {boolean} True if null, false if something changed.
*/
isNull(): boolean;
/**
* Run an event.
* @param {boolean} _forward True if run forward, false if run backward (undo).
*/
run(_forward: boolean): void;
/**
* Get workspace the event belongs to.
* @return {!Blockly.Workspace} The workspace the event belongs to.
* @throws {Error} if workspace is null.
* @protected
*/
getEventWorkspace_(): Blockly.Workspace;
}
}
declare module Blockly.Events {
class BlockDrag extends BlockDrag__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class BlockDrag__Class extends Blockly.Events.UiBase__Class {
/**
* Class for a block drag event.
* @param {!Blockly.Block=} opt_block The top block in the stack that is being
* dragged. Undefined for a blank event.
* @param {boolean=} opt_isStart Whether this is the start of a block drag.
* Undefined for a blank event.
* @param {!Array<!Blockly.Block>=} opt_blocks The blocks affected by this
* drag. Undefined for a blank event.
* @extends {Blockly.Events.UiBase}
* @constructor
*/
constructor(opt_block?: Blockly.Block, opt_isStart?: boolean, opt_blocks?: Blockly.Block[]);
/**
* Whether this is the start of a block drag.
* @type {boolean|undefined}
*/
isStart: boolean|any /*undefined*/;
/**
* The blocks affected by this drag event.
* @type {!Array<!Blockly.Block>|undefined}
*/
blocks: Blockly.Block[]|any /*undefined*/;
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
}
}
declare module Blockly.Events {
class BubbleOpen extends BubbleOpen__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class BubbleOpen__Class extends Blockly.Events.UiBase__Class {
/**
* Class for a bubble open event.
* @param {Blockly.BlockSvg} opt_block The associated block. Undefined for a
* blank event.
* @param {boolean=} opt_isOpen Whether the bubble is opening (false if
* closing). Undefined for a blank event.
* @param {string=} opt_bubbleType The type of bubble. One of 'mutator', 'comment'
* or 'warning'. Undefined for a blank event.
* @extends {Blockly.Events.UiBase}
* @constructor
*/
constructor(opt_block: Blockly.BlockSvg, opt_isOpen?: boolean, opt_bubbleType?: string);
/**
* Whether the bubble is opening (false if closing).
* @type {boolean|undefined}
*/
isOpen: boolean|any /*undefined*/;
/**
* The type of bubble. One of 'mutator', 'comment', or 'warning'.
* @type {string|undefined}
*/
bubbleType: string|any /*undefined*/;
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
}
}
declare module Blockly.Events {
class Click extends Click__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Click__Class extends Blockly.Events.UiBase__Class {
/**
* Class for a click event.
* @param {?Blockly.Block=} opt_block The affected block. Null for click events
* that do not have an associated block (i.e. workspace click). Undefined
* for a blank event.
* @param {?string=} opt_workspaceId The workspace identifier for this event.
* Not used if block is passed. Undefined for a blank event.
* @param {string=} opt_targetType The type of element targeted by this click
* event. Undefined for a blank event.
* @extends {Blockly.Events.UiBase}
* @constructor
*/
constructor(opt_block?: Blockly.Block, opt_workspaceId?: string, opt_targetType?: string);
/**
* The type of element targeted by this click event.
* @type {string|undefined}
*/
targetType: string|any /*undefined*/;
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
}
}
declare module Blockly.Events {
class MarkerMove extends MarkerMove__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class MarkerMove__Class extends Blockly.Events.UiBase__Class {
/**
* Class for a marker move event.
* @param {?Blockly.Block=} opt_block The affected block. Null if current node
* is of type workspace. Undefined for a blank event.
* @param {boolean=} isCursor Whether this is a cursor event. Undefined for a
* blank event.
* @param {?Blockly.ASTNode=} opt_oldNode The old node the marker used to be on.
* Undefined for a blank event.
* @param {!Blockly.ASTNode=} opt_newNode The new node the marker is now on.
* Undefined for a blank event.
* @extends {Blockly.Events.UiBase}
* @constructor
*/
constructor(opt_block?: Blockly.Block, isCursor?: boolean, opt_oldNode?: Blockly.ASTNode, opt_newNode?: Blockly.ASTNode);
/**
* The workspace identifier for this event.
* @type {?string}
*/
blockId: string;
/**
* The old node the marker used to be on.
* @type {?Blockly.ASTNode|undefined}
*/
oldNode: Blockly.ASTNode|any /*undefined*/;
/**
* The new node the marker is now on.
* @type {Blockly.ASTNode|undefined}
*/
newNode: Blockly.ASTNode|any /*undefined*/;
/**
* Whether this is a cursor event.
* @type {boolean|undefined}
*/
isCursor: boolean|any /*undefined*/;
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
}
}
declare module Blockly.Events {
class Selected extends Selected__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Selected__Class extends Blockly.Events.UiBase__Class {
/**
* Class for a selected event.
* @param {?string=} opt_oldElementId The ID of the previously selected
* element. Null if no element last selected. Undefined for a blank event.
* @param {?string=} opt_newElementId The ID of the selected element. Null if no
* element currently selected (deselect). Undefined for a blank event.
* @param {string=} opt_workspaceId The workspace identifier for this event.
* Null if no element previously selected. Undefined for a blank event.
* @extends {Blockly.Events.UiBase}
* @constructor
*/
constructor(opt_oldElementId?: string, opt_newElementId?: string, opt_workspaceId?: string);
/**
* The id of the last selected element.
* @type {?string|undefined}
*/
oldElementId: string|any /*undefined*/;
/**
* The id of the selected element.
* @type {?string|undefined}
*/
newElementId: string|any /*undefined*/;
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
}
}
declare module Blockly.Events {
class ThemeChange extends ThemeChange__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class ThemeChange__Class extends Blockly.Events.UiBase__Class {
/**
* Class for a theme change event.
* @param {string=} opt_themeName The theme name. Undefined for a blank event.
* @param {string=} opt_workspaceId The workspace identifier for this event.
* event. Undefined for a blank event.
* @extends {Blockly.Events.UiBase}
* @constructor
*/
constructor(opt_themeName?: string, opt_workspaceId?: string);
/**
* The theme name.
* @type {string|undefined}
*/
themeName: string|any /*undefined*/;
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
}
}
declare module Blockly.Events {
class ToolboxItemSelect extends ToolboxItemSelect__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class ToolboxItemSelect__Class extends Blockly.Events.UiBase__Class {
/**
* Class for a toolbox item select event.
* @param {?string=} opt_oldItem The previously selected toolbox item. Undefined
* for a blank event.
* @param {?string=} opt_newItem The newly selected toolbox item. Undefined for
* a blank event.
* @param {string=} opt_workspaceId The workspace identifier for this event.
* Undefined for a blank event.
* @extends {Blockly.Events.UiBase}
* @constructor
*/
constructor(opt_oldItem?: string, opt_newItem?: string, opt_workspaceId?: string);
/**
* The previously selected toolbox item.
* @type {?string|undefined}
*/
oldItem: string|any /*undefined*/;
/**
* The newly selected toolbox item.
* @type {?string|undefined}
*/
newItem: string|any /*undefined*/;
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
}
}
declare module Blockly.Events {
class TrashcanOpen extends TrashcanOpen__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class TrashcanOpen__Class extends Blockly.Events.UiBase__Class {
/**
* Class for a trashcan open event.
* @param {boolean=} opt_isOpen Whether the trashcan flyout is opening (false if
* opening). Undefined for a blank event.
* @param {string=} opt_workspaceId The workspace identifier for this event.
* Undefined for a blank event.
* @extends {Blockly.Events.UiBase}
* @constructor
*/
constructor(opt_isOpen?: boolean, opt_workspaceId?: string);
/**
* Whether the trashcan flyout is opening (false if closing).
* @type {boolean|undefined}
*/
isOpen: boolean|any /*undefined*/;
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
}
}
declare module Blockly.Events {
class ViewportChange extends ViewportChange__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class ViewportChange__Class extends Blockly.Events.UiBase__Class {
/**
* Class for a viewport change event.
* @param {number=} opt_top Top-edge of the visible portion of the workspace,
* relative to the workspace origin. Undefined for a blank event.
* @param {number=} opt_left Left-edge of the visible portion of the workspace,
* relative to the workspace origin. Undefined for a blank event.
* @param {number=} opt_scale The scale of the workspace. Undefined for a blank
* event.
* @param {string=} opt_workspaceId The workspace identifier for this event.
* Undefined for a blank event.
* @param {number=} opt_oldScale The old scale of the workspace. Undefined for a
* blank event.
* @extends {Blockly.Events.UiBase}
* @constructor
*/
constructor(opt_top?: number, opt_left?: number, opt_scale?: number, opt_workspaceId?: string, opt_oldScale?: number);
/**
* Top-edge of the visible portion of the workspace, relative to the workspace
* origin.
* @type {number|undefined}
*/
viewTop: number|any /*undefined*/;
/**
* Left-edge of the visible portion of the workspace, relative to the
* workspace origin.
* @type {number|undefined}
*/
viewLeft: number|any /*undefined*/;
/**
* The scale of the workspace.
* @type {number|undefined}
*/
scale: number|any /*undefined*/;
/**
* The old scale of the workspace.
* @type {number|undefined}
*/
oldScale: number|any /*undefined*/;
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
}
}
declare module Blockly.Events {
class UiBase extends UiBase__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class UiBase__Class extends Blockly.Events.Abstract__Class {
/**
* Base class for a UI event.
* UI events are events that don't need to be sent over the wire for multi-user
* editing to work (e.g. scrolling the workspace, zooming, opening toolbox
* categories).
* UI events do not undo or redo.
* @param {string=} opt_workspaceId The workspace identifier for this event.
* Undefined for a blank event.
* @extends {Blockly.Events.Abstract}
* @constructor
*/
constructor(opt_workspaceId?: string);
/**
* Whether or not the event is blank (to be populated by fromJson).
* @type {boolean}
*/
isBlank: boolean;
/**
* The workspace identifier for this event.
* @type {string}
*/
workspaceId: string;
/**
* Whether or not the event is a UI event.
* @type {boolean}
*/
isUiEvent: boolean;
}
class Ui extends Ui__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Ui__Class extends Blockly.Events.UiBase__Class {
/**
* Class for a UI event.
* @param {?Blockly.Block=} opt_block The affected block. Null for UI events
* that do not have an associated block. Undefined for a blank event.
* @param {string=} opt_element One of 'selected', 'comment', 'mutatorOpen',
* etc.
* @param {*=} opt_oldValue Previous value of element.
* @param {*=} opt_newValue New value of element.
* @extends {Blockly.Events.UiBase}
* @deprecated December 2020. Instead use a more specific UI event.
* @constructor
*/
constructor(opt_block?: Blockly.Block, opt_element?: string, opt_oldValue?: any, opt_newValue?: any);
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
}
}
declare module Blockly.Events {
class VarBase extends VarBase__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class VarBase__Class extends Blockly.Events.Abstract__Class {
/**
* Abstract class for a variable event.
* @param {!Blockly.VariableModel=} opt_variable The variable this event
* corresponds to. Undefined for a blank event.
* @extends {Blockly.Events.Abstract}
* @constructor
*/
constructor(opt_variable?: Blockly.VariableModel);
/**
* The variable id for the variable this event pertains to.
* @type {string}
*/
varId: string;
/**
* The workspace identifier for this event.
* @type {string}
*/
workspaceId: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
}
class VarCreate extends VarCreate__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class VarCreate__Class extends Blockly.Events.VarBase__Class {
/**
* Class for a variable creation event.
* @param {!Blockly.VariableModel=} opt_variable The created variable. Undefined
* for a blank event.
* @extends {Blockly.Events.VarBase}
* @constructor
*/
constructor(opt_variable?: Blockly.VariableModel);
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
/**
* Run a variable creation event.
* @param {boolean} forward True if run forward, false if run backward (undo).
*/
run(forward: boolean): void;
}
class VarDelete extends VarDelete__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class VarDelete__Class extends Blockly.Events.VarBase__Class {
/**
* Class for a variable deletion event.
* @param {!Blockly.VariableModel=} opt_variable The deleted variable. Undefined
* for a blank event.
* @extends {Blockly.Events.VarBase}
* @constructor
*/
constructor(opt_variable?: Blockly.VariableModel);
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
/**
* Run a variable deletion event.
* @param {boolean} forward True if run forward, false if run backward (undo).
*/
run(forward: boolean): void;
}
class VarRename extends VarRename__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class VarRename__Class extends Blockly.Events.VarBase__Class {
/**
* Class for a variable rename event.
* @param {!Blockly.VariableModel=} opt_variable The renamed variable. Undefined
* for a blank event.
* @param {string=} newName The new name the variable will be changed to.
* @extends {Blockly.Events.VarBase}
* @constructor
*/
constructor(opt_variable?: Blockly.VariableModel, newName?: string);
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
/**
* Run a variable rename event.
* @param {boolean} forward True if run forward, false if run backward (undo).
*/
run(forward: boolean): void;
}
}
declare module Blockly.Events {
class FinishedLoading extends FinishedLoading__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class FinishedLoading__Class extends Blockly.Events.Abstract__Class {
/**
* Class for a finished loading event.
* Used to notify the developer when the workspace has finished loading (i.e
* domToWorkspace).
* Finished loading events do not record undo or redo.
* @param {!Blockly.Workspace=} opt_workspace The workspace that has finished
* loading. Undefined for a blank event.
* @extends {Blockly.Events.Abstract}
* @constructor
*/
constructor(opt_workspace?: Blockly.Workspace);
/**
* Whether or not the event is blank (to be populated by fromJson).
* @type {boolean}
*/
isBlank: boolean;
/**
* The workspace identifier for this event.
* @type {string}
*/
workspaceId: string;
/**
* The event group ID for the group this event belongs to. Groups define
* events that should be treated as an single action from the user's
* perspective, and should be undone together.
* @type {string}
*/
group: string;
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
}
}
declare module Blockly.Events {
class CommentBase extends CommentBase__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class CommentBase__Class extends Blockly.Events.Abstract__Class {
/**
* Abstract class for a comment event.
* @param {!Blockly.WorkspaceComment=} opt_comment The comment this event
* corresponds to. Undefined for a blank event.
* @extends {Blockly.Events.Abstract}
* @constructor
*/
constructor(opt_comment?: Blockly.WorkspaceComment);
/**
* Whether or not an event is blank.
* @type {boolean}
*/
isBlank: boolean;
/**
* The ID of the comment this event pertains to.
* @type {string}
*/
commentId: string;
/**
* The workspace identifier for this event.
* @type {string}
*/
workspaceId: string;
/**
* The event group id for the group this event belongs to. Groups define
* events that should be treated as an single action from the user's
* perspective, and should be undone together.
* @type {string}
*/
group: string;
/**
* Sets whether the event should be added to the undo stack.
* @type {boolean}
*/
recordUndo: boolean;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
}
class CommentChange extends CommentChange__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class CommentChange__Class extends Blockly.Events.CommentBase__Class {
/**
* Class for a comment change event.
* @param {!Blockly.WorkspaceComment=} opt_comment The comment that is being
* changed. Undefined for a blank event.
* @param {string=} opt_oldContents Previous contents of the comment.
* @param {string=} opt_newContents New contents of the comment.
* @extends {Blockly.Events.CommentBase}
* @constructor
*/
constructor(opt_comment?: Blockly.WorkspaceComment, opt_oldContents?: string, opt_newContents?: string);
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
/**
* Does this event record any change of state?
* @return {boolean} False if something changed.
*/
isNull(): boolean;
/**
* Run a change event.
* @param {boolean} forward True if run forward, false if run backward (undo).
*/
run(forward: boolean): void;
}
class CommentCreate extends CommentCreate__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class CommentCreate__Class extends Blockly.Events.CommentBase__Class {
/**
* Class for a comment creation event.
* @param {!Blockly.WorkspaceComment=} opt_comment The created comment.
* Undefined for a blank event.
* @extends {Blockly.Events.CommentBase}
* @constructor
*/
constructor(opt_comment?: Blockly.WorkspaceComment);
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
/**
* Run a creation event.
* @param {boolean} forward True if run forward, false if run backward (undo).
*/
run(forward: boolean): void;
}
class CommentDelete extends CommentDelete__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class CommentDelete__Class extends Blockly.Events.CommentBase__Class {
/**
* Class for a comment deletion event.
* @param {!Blockly.WorkspaceComment=} opt_comment The deleted comment.
* Undefined for a blank event.
* @extends {Blockly.Events.CommentBase}
* @constructor
*/
constructor(opt_comment?: Blockly.WorkspaceComment);
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
/**
* Run a creation event.
* @param {boolean} forward True if run forward, false if run backward (undo).
*/
run(forward: boolean): void;
}
class CommentMove extends CommentMove__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class CommentMove__Class extends Blockly.Events.CommentBase__Class {
/**
* Class for a comment move event. Created before the move.
* @param {!Blockly.WorkspaceComment=} opt_comment The comment that is being
* moved. Undefined for a blank event.
* @extends {Blockly.Events.CommentBase}
* @constructor
*/
constructor(opt_comment?: Blockly.WorkspaceComment);
/**
* The comment that is being moved. Will be cleared after recording the new
* location.
* @type {Blockly.WorkspaceComment}
*/
comment_: Blockly.WorkspaceComment;
/**
* The location before the move, in workspace coordinates.
* @type {!Blockly.utils.Coordinate}
*/
oldCoordinate_: Blockly.utils.Coordinate;
/**
* The location after the move, in workspace coordinates.
* @type {Blockly.utils.Coordinate}
*/
newCoordinate_: Blockly.utils.Coordinate;
/**
* Record the comment's new location. Called after the move. Can only be
* called once.
*/
recordNew(): void;
/**
* Type of this event.
* @type {string}
*/
type: string;
/**
* Override the location before the move. Use this if you don't create the
* event until the end of the move, but you know the original location.
* @param {!Blockly.utils.Coordinate} xy The location before the move,
* in workspace coordinates.
*/
setOldCoordinate(xy: Blockly.utils.Coordinate): void;
/**
* Encode the event as JSON.
* @return {!Object} JSON representation.
*/
toJson(): Object;
/**
* Decode the JSON event.
* @param {!Object} json JSON representation.
*/
fromJson(json: Object): void;
/**
* Does this event record any change of state?
* @return {boolean} False if something changed.
*/
isNull(): boolean;
/**
* Run a move event.
* @param {boolean} forward True if run forward, false if run backward (undo).
*/
run(forward: boolean): void;
}
/**
* Helper function for Comment[Create|Delete]
* @param {!Blockly.Events.CommentCreate|!Blockly.Events.CommentDelete} event
* The event to run.
* @param {boolean} create if True then Create, if False then Delete
*/
function CommentCreateDeleteHelper(event: Blockly.Events.CommentCreate|Blockly.Events.CommentDelete, create: boolean): void;
}
declare module Blockly {
interface IASTNodeLocation {
}
interface IASTNodeLocationSvg extends Blockly.IASTNodeLocation {
/**
* Add the marker SVG to this node's SVG group.
* @param {SVGElement} markerSvg The SVG root of the marker to be added to the
* SVG group.
*/
setMarkerSvg(markerSvg: SVGElement): void;
/**
* Add the cursor SVG to this node's SVG group.
* @param {SVGElement} cursorSvg The SVG root of the cursor to be added to the
* SVG group.
*/
setCursorSvg(cursorSvg: SVGElement): void;
}
interface IASTNodeLocationWithBlock extends Blockly.IASTNodeLocation {
/**
* Get the source block associated with this node.
* @return {Blockly.Block} The source block.
*/
getSourceBlock(): Blockly.Block;
}
interface IKeyboardAccessible {
/**
* Handles the given keyboard shortcut.
* @param {!Blockly.ShortcutRegistry.KeyboardShortcut} shortcut The shortcut to be handled.
* @return {boolean} True if the shortcut has been handled, false otherwise.
*/
onShortcut(shortcut: Blockly.ShortcutRegistry.KeyboardShortcut): boolean;
}
}
declare module Blockly {
interface IAutoHideable extends Blockly.IComponent {
/**
* Hides the component. Called in Blockly.hideChaff.
* @param {boolean} onlyClosePopups Whether only popups should be closed.
* Flyouts should not be closed if this is true.
*/
autoHide(onlyClosePopups: boolean): void;
}
}
declare module Blockly {
interface IBlockDragger {
/**
* Start dragging a block. This includes moving it to the drag surface.
* @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
* moved from the position at mouse down, in pixel units.
* @param {boolean} healStack Whether or not to heal the stack after
* disconnecting.
*/
startDrag(currentDragDeltaXY: Blockly.utils.Coordinate, healStack: boolean): void;
/**
* Execute a step of block dragging, based on the given event. Update the
* display accordingly.
* @param {!Event} e The most recent move event.
* @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
* moved from the position at the start of the drag, in pixel units.
*/
drag(e: Event, currentDragDeltaXY: Blockly.utils.Coordinate): void;
/**
* Finish a block drag and put the block back on the workspace.
* @param {!Event} e The mouseup/touchend event.
* @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
* moved from the position at the start of the drag, in pixel units.
*/
endDrag(e: Event, currentDragDeltaXY: Blockly.utils.Coordinate): void;
/**
* Get a list of the insertion markers that currently exist. Drags have 0, 1,
* or 2 insertion markers.
* @return {!Array.<!Blockly.BlockSvg>} A possibly empty list of insertion
* marker blocks.
*/
getInsertionMarkers(): Blockly.BlockSvg[];
}
}
declare module Blockly {
interface IBoundedElement {
/**
* Returns the coordinates of a bounded element describing the dimensions of the
* element.
* Coordinate system: workspace coordinates.
* @return {!Blockly.utils.Rect} Object with coordinates of the bounded element.
*/
getBoundingRectangle(): Blockly.utils.Rect;
/**
* Move the element by a relative offset.
* @param {number} dx Horizontal offset in workspace units.
* @param {number} dy Vertical offset in workspace units.
*/
moveBy(dx: number, dy: number): void;
}
}
declare module Blockly {
interface IBubble extends Blockly.IDraggable, Blockly.IContextMenu {
/**
* Return the coordinates of the top-left corner of this bubble's body relative
* to the drawing surface's origin (0,0), in workspace units.
* @return {!Blockly.utils.Coordinate} Object with .x and .y properties.
*/
getRelativeToSurfaceXY(): Blockly.utils.Coordinate;
/**
* Return the root node of the bubble's SVG group.
* @return {!SVGElement} The root SVG node of the bubble's group.
*/
getSvgRoot(): SVGElement;
/**
* Set whether auto-layout of this bubble is enabled. The first time a bubble
* is shown it positions itself to not cover any blocks. Once a user has
* dragged it to reposition, it renders where the user put it.
* @param {boolean} enable True if auto-layout should be enabled, false
* otherwise.
*/
setAutoLayout(enable: boolean): void;
/**
* Triggers a move callback if one exists at the end of a drag.
* @param {boolean} adding True if adding, false if removing.
*/
setDragging(adding: boolean): void;
/**
* Move this bubble during a drag, taking into account whether or not there is
* a drag surface.
* @param {Blockly.BlockDragSurfaceSvg} dragSurface The surface that carries
* rendered items during a drag, or null if no drag surface is in use.
* @param {!Blockly.utils.Coordinate} newLoc The location to translate to, in
* workspace coordinates.
*/
moveDuringDrag(dragSurface: Blockly.BlockDragSurfaceSvg, newLoc: Blockly.utils.Coordinate): void;
/**
* Move the bubble to the specified location in workspace coordinates.
* @param {number} x The x position to move to.
* @param {number} y The y position to move to.
*/
moveTo(x: number, y: number): void;
/**
* Update the style of this bubble when it is dragged over a delete area.
* @param {boolean} enable True if the bubble is about to be deleted, false
* otherwise.
*/
setDeleteStyle(enable: boolean): void;
/**
* Dispose of this bubble.
*/
dispose: any /*missing*/;
}
}
declare module Blockly {
interface IComponent {
}
}
declare module Blockly.IComponent {
/**
* The unique id for this component that is used to register with the
* ComponentManager.
* @type {string}
*/
var id: string;
}
declare module Blockly {
interface IConnectionChecker {
/**
* Check whether the current connection can connect with the target
* connection.
* @param {Blockly.Connection} a Connection to check compatibility with.
* @param {Blockly.Connection} b Connection to check compatibility with.
* @param {boolean} isDragging True if the connection is being made by dragging
* a block.
* @param {number=} opt_distance The max allowable distance between the
* connections for drag checks.
* @return {boolean} Whether the connection is legal.
* @public
*/
canConnect(a: Blockly.Connection, b: Blockly.Connection, isDragging: boolean, opt_distance?: number): boolean;
/**
* Checks whether the current connection can connect with the target
* connection, and return an error code if there are problems.
* @param {Blockly.Connection} a Connection to check compatibility with.
* @param {Blockly.Connection} b Connection to check compatibility with.
* @param {boolean} isDragging True if the connection is being made by dragging
* a block.
* @param {number=} opt_distance The max allowable distance between the
* connections for drag checks.
* @return {number} Blockly.Connection.CAN_CONNECT if the connection is legal,
* an error code otherwise.
* @public
*/
canConnectWithReason(a: Blockly.Connection, b: Blockly.Connection, isDragging: boolean, opt_distance?: number): number;
/**
* Helper method that translates a connection error code into a string.
* @param {number} errorCode The error code.
* @param {Blockly.Connection} a One of the two connections being checked.
* @param {Blockly.Connection} b The second of the two connections being
* checked.
* @return {string} A developer-readable error string.
* @public
*/
getErrorMessage(errorCode: number, a: Blockly.Connection, b: Blockly.Connection): string;
/**
* Check that connecting the given connections is safe, meaning that it would
* not break any of Blockly's basic assumptions (e.g. no self connections).
* @param {Blockly.Connection} a The first of the connections to check.
* @param {Blockly.Connection} b The second of the connections to check.
* @return {number} An enum with the reason this connection is safe or unsafe.
* @public
*/
doSafetyChecks(a: Blockly.Connection, b: Blockly.Connection): number;
/**
* Check whether this connection is compatible with another connection with
* respect to the value type system. E.g. square_root("Hello") is not
* compatible.
* @param {!Blockly.Connection} a Connection to compare.
* @param {!Blockly.Connection} b Connection to compare against.
* @return {boolean} True if the connections share a type.
* @public
*/
doTypeChecks(a: Blockly.Connection, b: Blockly.Connection): boolean;
/**
* Check whether this connection can be made by dragging.
* @param {!Blockly.RenderedConnection} a Connection to compare.
* @param {!Blockly.RenderedConnection} b Connection to compare against.
* @param {number} distance The maximum allowable distance between connections.
* @return {boolean} True if the connection is allowed during a drag.
* @public
*/
doDragChecks(a: Blockly.RenderedConnection, b: Blockly.RenderedConnection, distance: number): boolean;
}
}
declare module Blockly {
interface IContextMenu {
/**
* Show the context menu for this object.
* @param {!Event} e Mouse event.
*/
showContextMenu(e: Event): void;
}
}
declare module Blockly {
interface ICopyable extends Blockly.ISelectable {
/**
* Encode for copying.
* @return {?Blockly.ICopyable.CopyData} Copy metadata.
*/
toCopyData(): Blockly.ICopyable.CopyData;
}
}
declare module Blockly.ICopyable {
/**
* Copy Metadata.
* @typedef {{
* xml:!Element,
* source:Blockly.WorkspaceSvg,
* typeCounts:?Object
* }}
*/
interface CopyData {
xml: Element;
source: Blockly.WorkspaceSvg;
typeCounts: Object
}
}
declare module Blockly {
interface IDeletable {
/**
* Get whether this object is deletable or not.
* @return {boolean} True if deletable.
*/
isDeletable(): boolean;
}
}
declare module Blockly {
interface IDeleteArea extends Blockly.IDragTarget {
/**
* Returns whether the provided block or bubble would be deleted if dropped on
* this area.
* This method should check if the element is deletable and is always called
* before onDragEnter/onDragOver/onDragExit.
* @param {!Blockly.IDraggable} element The block or bubble currently being
* dragged.
* @param {boolean} couldConnect Whether the element could could connect to
* another.
* @return {boolean} Whether the element provided would be deleted if dropped on
* this area.
*/
wouldDelete(element: Blockly.IDraggable, couldConnect: boolean): boolean;
}
}
declare module Blockly {
interface IDragTarget extends Blockly.IComponent {
/**
* Returns the bounding rectangle of the drag target area in pixel units
* relative to viewport.
* @return {?Blockly.utils.Rect} The component's bounding box. Null if drag
* target area should be ignored.
*/
getClientRect(): Blockly.utils.Rect;
/**
* Handles when a cursor with a block or bubble enters this drag target.
* @param {!Blockly.IDraggable} dragElement The block or bubble currently being
* dragged.
*/
onDragEnter(dragElement: Blockly.IDraggable): void;
/**
* Handles when a cursor with a block or bubble is dragged over this drag
* target.
* @param {!Blockly.IDraggable} dragElement The block or bubble currently being
* dragged.
*/
onDragOver(dragElement: Blockly.IDraggable): void;
/**
* Handles when a cursor with a block or bubble exits this drag target.
* @param {!Blockly.IDraggable} dragElement The block or bubble currently being
* dragged.
*/
onDragExit(dragElement: Blockly.IDraggable): void;
/**
* Handles when a block or bubble is dropped on this component.
* Should not handle delete here.
* @param {!Blockly.IDraggable} dragElement The block or bubble currently being
* dragged.
*/
onDrop(dragElement: Blockly.IDraggable): void;
/**
* Returns whether the provided block or bubble should not be moved after being
* dropped on this component. If true, the element will return to where it was
* when the drag started.
* @param {!Blockly.IDraggable} dragElement The block or bubble currently being
* dragged.
* @return {boolean} Whether the block or bubble provided should be returned to
* drag start.
*/
shouldPreventMove(dragElement: Blockly.IDraggable): boolean;
}
}
declare module Blockly {
interface IDraggable extends Blockly.IDeletable {
}
}
declare module Blockly {
interface IFlyout extends Blockly.IRegistrable {
/**
* Whether the flyout is laid out horizontally or not.
* @type {boolean}
*/
horizontalLayout: boolean;
/**
* Is RTL vs LTR.
* @type {boolean}
*/
RTL: boolean;
/**
* The target workspace
* @type {?Blockly.WorkspaceSvg}
*/
targetWorkspace: Blockly.WorkspaceSvg;
/**
* Margin around the edges of the blocks in the flyout.
* @type {number}
* @const
*/
MARGIN: number;
/**
* Does the flyout automatically close when a block is created?
* @type {boolean}
*/
autoClose: boolean;
/**
* Corner radius of the flyout background.
* @type {number}
* @const
*/
CORNER_RADIUS: number;
/**
* Creates the flyout's DOM. Only needs to be called once. The flyout can
* either exist as its own svg element or be a g element nested inside a
* separate svg element.
* @param {string|
* !Blockly.utils.Svg<!SVGSVGElement>|
* !Blockly.utils.Svg<!SVGGElement>} tagName The type of tag to
* put the flyout in. This should be <svg> or <g>.
* @return {!SVGElement} The flyout's SVG group.
*/
createDom(tagName: string|Blockly.utils.Svg<SVGSVGElement>|Blockly.utils.Svg<SVGGElement>): SVGElement;
/**
* Initializes the flyout.
* @param {!Blockly.WorkspaceSvg} targetWorkspace The workspace in which to
* create new blocks.
*/
init(targetWorkspace: Blockly.WorkspaceSvg): void;
/**
* Dispose of this flyout.
* Unlink from all DOM elements to prevent memory leaks.
*/
dispose: any /*missing*/;
/**
* Get the width of the flyout.
* @return {number} The width of the flyout.
*/
getWidth(): number;
/**
* Get the height of the flyout.
* @return {number} The width of the flyout.
*/
getHeight(): number;
/**
* Get the workspace inside the flyout.
* @return {!Blockly.WorkspaceSvg} The workspace inside the flyout.
*/
getWorkspace(): Blockly.WorkspaceSvg;
/**
* Is the flyout visible?
* @return {boolean} True if visible.
*/
isVisible(): boolean;
/**
* Set whether the flyout is visible. A value of true does not necessarily mean
* that the flyout is shown. It could be hidden because its container is hidden.
* @param {boolean} visible True if visible.
*/
setVisible(visible: boolean): void;
/**
* Set whether this flyout's container is visible.
* @param {boolean} visible Whether the container is visible.
*/
setContainerVisible(visible: boolean): void;
/**
* Hide and empty the flyout.
*/
hide: any /*missing*/;
/**
* Show and populate the flyout.
* @param {!Blockly.utils.toolbox.FlyoutDefinition|string} flyoutDef Contents to
* display in the flyout. This is either an array of Nodes, a NodeList, a
* toolbox definition, or a string with the name of the dynamic category.
*/
show(flyoutDef: Blockly.utils.toolbox.FlyoutDefinition|string): void;
/**
* Create a copy of this block on the workspace.
* @param {!Blockly.BlockSvg} originalBlock The block to copy from the flyout.
* @return {!Blockly.BlockSvg} The newly created block.
* @throws {Error} if something went wrong with deserialization.
*/
createBlock(originalBlock: Blockly.BlockSvg): Blockly.BlockSvg;
/**
* Reflow blocks and their mats.
*/
reflow: any /*missing*/;
/**
* @return {boolean} True if this flyout may be scrolled with a scrollbar or by
* dragging.
*/
isScrollable(): boolean;
/**
* Calculates the x coordinate for the flyout position.
* @return {number} X coordinate.
*/
getX(): number;
/**
* Calculates the y coordinate for the flyout position.
* @return {number} Y coordinate.
*/
getY(): number;
/**
* Position the flyout.
* @return {void}
*/
position(): void;
/**
* Determine if a drag delta is toward the workspace, based on the position
* and orientation of the flyout. This is used in determineDragIntention_ to
* determine if a new block should be created or if the flyout should scroll.
* @param {!Blockly.utils.Coordinate} currentDragDeltaXY How far the pointer has
* moved from the position at mouse down, in pixel units.
* @return {boolean} True if the drag is toward the workspace.
*/
isDragTowardWorkspace(currentDragDeltaXY: Blockly.utils.Coordinate): boolean;
}
}
declare module Blockly {
interface IMetricsManager {
/**
* Returns whether the scroll area has fixed edges.
* @return {boolean} Whether the scroll area has fixed edges.
* @package
*/
hasFixedEdges(): boolean;
/**
* Returns the metrics for the scroll area of the workspace.
* @param {boolean=} opt_getWorkspaceCoordinates True to get the scroll metrics
* in workspace coordinates, false to get them in pixel coordinates.
* @param {!Blockly.MetricsManager.ContainerRegion=} opt_viewMetrics The view
* metrics if they have been previously computed. Passing in null may cause
* the view metrics to be computed again, if it is needed.
* @param {!Blockly.MetricsManager.ContainerRegion=} opt_contentMetrics The
* content metrics if they have been previously computed. Passing in null
* may cause the content metrics to be computed again, if it is needed.
* @return {!Blockly.MetricsManager.ContainerRegion} The metrics for the scroll
* container
*/
getScrollMetrics(opt_getWorkspaceCoordinates?: boolean, opt_viewMetrics?: Blockly.MetricsManager.ContainerRegion, opt_contentMetrics?: Blockly.MetricsManager.ContainerRegion): Blockly.MetricsManager.ContainerRegion;
/**
* Gets the width and the height of the flyout on the workspace in pixel
* coordinates. Returns 0 for the width and height if the workspace has a
* category toolbox instead of a simple toolbox.
* @param {boolean=} opt_own Whether to only return the workspace's own flyout.
* @return {!Blockly.MetricsManager.ToolboxMetrics} The width and height of the
* flyout.
* @public
*/
getFlyoutMetrics(opt_own?: boolean): Blockly.MetricsManager.ToolboxMetrics;
/**
* Gets the width, height and position of the toolbox on the workspace in pixel
* coordinates. Returns 0 for the width and height if the workspace has a simple
* toolbox instead of a category toolbox. To get the width and height of a
* simple toolbox @see {@link getFlyoutMetrics}.
* @return {!Blockly.MetricsManager.ToolboxMetrics} The object with the width,
* height and position of the toolbox.
* @public
*/
getToolboxMetrics(): Blockly.MetricsManager.ToolboxMetrics;
/**
* Gets the width and height of the workspace's parent SVG element in pixel
* coordinates. This area includes the toolbox and the visible workspace area.
* @return {!Blockly.utils.Size} The width and height of the workspace's parent
* SVG element.
* @public
*/
getSvgMetrics(): Blockly.utils.Size;
/**
* Gets the absolute left and absolute top in pixel coordinates.
* This is where the visible workspace starts in relation to the SVG container.
* @return {!Blockly.MetricsManager.AbsoluteMetrics} The absolute metrics for
* the workspace.
* @public
*/
getAbsoluteMetrics(): Blockly.MetricsManager.AbsoluteMetrics;
/**
* Gets the metrics for the visible workspace in either pixel or workspace
* coordinates. The visible workspace does not include the toolbox or flyout.
* @param {boolean=} opt_getWorkspaceCoordinates True to get the view metrics in
* workspace coordinates, false to get them in pixel coordinates.
* @return {!Blockly.MetricsManager.ContainerRegion} The width, height, top and
* left of the viewport in either workspace coordinates or pixel
* coordinates.
* @public
*/
getViewMetrics(opt_getWorkspaceCoordinates?: boolean): Blockly.MetricsManager.ContainerRegion;
/**
* Gets content metrics in either pixel or workspace coordinates.
* The content area is a rectangle around all the top bounded elements on the
* workspace (workspace comments and blocks).
* @param {boolean=} opt_getWorkspaceCoordinates True to get the content metrics
* in workspace coordinates, false to get them in pixel coordinates.
* @return {!Blockly.MetricsManager.ContainerRegion} The
* metrics for the content container.
* @public
*/
getContentMetrics(opt_getWorkspaceCoordinates?: boolean): Blockly.MetricsManager.ContainerRegion;
/**
* Returns an object with all the metrics required to size scrollbars for a
* top level workspace. The following properties are computed:
* Coordinate system: pixel coordinates, -left, -up, +right, +down
* .viewHeight: Height of the visible portion of the workspace.
* .viewWidth: Width of the visible portion of the workspace.
* .contentHeight: Height of the content.
* .contentWidth: Width of the content.
* .svgHeight: Height of the Blockly div (the view + the toolbox,
* simple or otherwise),
* .svgWidth: Width of the Blockly div (the view + the toolbox,
* simple or otherwise),
* .viewTop: Top-edge of the visible portion of the workspace, relative to
* the workspace origin.
* .viewLeft: Left-edge of the visible portion of the workspace, relative to
* the workspace origin.
* .contentTop: Top-edge of the content, relative to the workspace origin.
* .contentLeft: Left-edge of the content relative to the workspace origin.
* .absoluteTop: Top-edge of the visible portion of the workspace, relative
* to the blocklyDiv.
* .absoluteLeft: Left-edge of the visible portion of the workspace, relative
* to the blocklyDiv.
* .toolboxWidth: Width of the toolbox, if it exists. Otherwise zero.
* .toolboxHeight: Height of the toolbox, if it exists. Otherwise zero.
* .flyoutWidth: Width of the flyout if it is always open. Otherwise zero.
* .flyoutHeight: Height of the flyout if it is always open. Otherwise zero.
* .toolboxPosition: Top, bottom, left or right. Use TOOLBOX_AT constants to
* compare.
* @return {!Blockly.utils.Metrics} Contains size and position metrics of a top
* level workspace.
* @public
*/
getMetrics(): Blockly.utils.Metrics;
}
}
declare module Blockly {
interface IMovable {
/**
* Get whether this is movable or not.
* @return {boolean} True if movable.
*/
isMovable(): boolean;
}
}
declare module Blockly {
interface IPositionable extends Blockly.IComponent {
/**
* Positions the element. Called when the window is resized.
* @param {!Blockly.MetricsManager.UiMetrics} metrics The workspace metrics.
* @param {!Array<!Blockly.utils.Rect>} savedPositions List of rectangles that
* are already on the workspace.
*/
position(metrics: Blockly.MetricsManager.UiMetrics, savedPositions: Blockly.utils.Rect[]): void;
/**
* Returns the bounding rectangle of the UI element in pixel units relative to
* the Blockly injection div.
* @return {?Blockly.utils.Rect} The UI elements’s bounding box. Null if
* bounding box should be ignored by other UI elements.
*/
getBoundingRectangle(): Blockly.utils.Rect;
}
}
declare module Blockly {
interface IRegistrable {
}
}
declare module Blockly {
/**
* A registrable field.
* Note: We are not using an interface here as we are interested in defining the
* static methods of a field rather than the instance methods.
* @typedef {{
* fromJson:Blockly.IRegistrableField.fromJson
* }}
*/
interface IRegistrableField {
fromJson: Blockly.IRegistrableField.fromJson
}
}
declare module Blockly.IRegistrableField {
/**
* @typedef {function(!Object): Blockly.Field}
*/
interface fromJson {
(_0: Object): Blockly.Field
}
}
declare module Blockly {
interface ISelectable extends Blockly.IDeletable, Blockly.IMovable {
/**
* @type {string}
*/
id: string;
/**
* Select this. Highlight it visually.
* @return {void}
*/
select(): void;
/**
* Unselect this. Unhighlight it visually.
* @return {void}
*/
unselect(): void;
}
}
declare module Blockly {
interface IStyleable {
/**
* Adds a style on the toolbox. Usually used to change the cursor.
* @param {string} style The name of the class to add.
*/
addStyle(style: string): void;
/**
* Removes a style from the toolbox. Usually used to change the cursor.
* @param {string} style The name of the class to remove.
*/
removeStyle(style: string): void;
}
}
declare module Blockly {
interface IToolbox extends Blockly.IRegistrable {
/**
* Initializes the toolbox.
* @return {void}
*/
init(): void;
/**
* Fills the toolbox with new toolbox items and removes any old contents.
* @param {!Blockly.utils.toolbox.ToolboxInfo} toolboxDef Object holding information
* for creating a toolbox.
*/
render(toolboxDef: Blockly.utils.toolbox.ToolboxInfo): void;
/**
* Gets the width of the toolbox.
* @return {number} The width of the toolbox.
*/
getWidth(): number;
/**
* Gets the height of the toolbox.
* @return {number} The width of the toolbox.
*/
getHeight(): number;
/**
* Gets the toolbox flyout.
* @return {?Blockly.IFlyout} The toolbox flyout.
*/
getFlyout(): Blockly.IFlyout;
/**
* Gets the workspace for the toolbox.
* @return {!Blockly.WorkspaceSvg} The parent workspace for the toolbox.
*/
getWorkspace(): Blockly.WorkspaceSvg;
/**
* Gets whether or not the toolbox is horizontal.
* @return {boolean} True if the toolbox is horizontal, false if the toolbox is
* vertical.
*/
isHorizontal(): boolean;
/**
* Positions the toolbox based on whether it is a horizontal toolbox and whether
* the workspace is in rtl.
* @return {void}
*/
position(): void;
/**
* Handles resizing the toolbox when a toolbox item resizes.
* @return {void}
*/
handleToolboxItemResize(): void;
/**
* Unhighlights any previously selected item.
* @return {void}
*/
clearSelection(): void;
/**
* Updates the category colours and background colour of selected categories.
* @return {void}
*/
refreshTheme(): void;
/**
* Updates the flyout's content without closing it. Should be used in response
* to a change in one of the dynamic categories, such as variables or
* procedures.
* @return {void}
*/
refreshSelection(): void;
/**
* Sets the visibility of the toolbox.
* @param {boolean} isVisible True if toolbox should be visible.
*/
setVisible(isVisible: boolean): void;
/**
* Selects the toolbox item by it's position in the list of toolbox items.
* @param {number} position The position of the item to select.
* @return {void}
*/
selectItemByPosition(position: number): void;
/**
* Gets the selected item.
* @return {?Blockly.IToolboxItem} The selected item, or null if no item is
* currently selected.
*/
getSelectedItem(): Blockly.IToolboxItem;
/**
* Disposes of this toolbox.
* @return {void}
*/
dispose(): void;
}
}
declare module Blockly {
interface IToolboxItem {
/**
* Initializes the toolbox item.
* This includes creating the DOM and updating the state of any items based
* on the info object.
* @return {void}
* @public
*/
init(): void;
/**
* Gets the div for the toolbox item.
* @return {?Element} The div for the toolbox item.
* @public
*/
getDiv(): Element;
/**
* Gets a unique identifier for this toolbox item.
* @return {string} The ID for the toolbox item.
* @public
*/
getId(): string;
/**
* Gets the parent if the toolbox item is nested.
* @return {?Blockly.IToolboxItem} The parent toolbox item, or null if
* this toolbox item is not nested.
* @public
*/
getParent(): Blockly.IToolboxItem;
/**
* Gets the nested level of the category.
* @return {number} The nested level of the category.
* @package
*/
getLevel(): number;
/**
* Whether the toolbox item is selectable.
* @return {boolean} True if the toolbox item can be selected.
* @public
*/
isSelectable(): boolean;
/**
* Whether the toolbox item is collapsible.
* @return {boolean} True if the toolbox item is collapsible.
* @public
*/
isCollapsible(): boolean;
/**
* Dispose of this toolbox item. No-op by default.
* @public
*/
dispose: any /*missing*/;
}
interface ISelectableToolboxItem extends Blockly.IToolboxItem {
/**
* Gets the name of the toolbox item. Used for emitting events.
* @return {string} The name of the toolbox item.
* @public
*/
getName(): string;
/**
* Gets the contents of the toolbox item. These are items that are meant to be
* displayed in the flyout.
* @return {!Blockly.utils.toolbox.FlyoutItemInfoArray|string} The definition
* of items to be displayed in the flyout.
* @public
*/
getContents(): Blockly.utils.toolbox.FlyoutItemInfoArray|string;
/**
* Sets the current toolbox item as selected.
* @param {boolean} _isSelected True if this category is selected, false
* otherwise.
* @public
*/
setSelected(_isSelected: boolean): void;
/**
* Gets the HTML element that is clickable.
* The parent toolbox element receives clicks. The parent toolbox will add an ID
* to this element so it can pass the onClick event to the correct toolboxItem.
* @return {!Element} The HTML element that receives clicks.
* @public
*/
getClickTarget(): Element;
/**
* Handles when the toolbox item is clicked.
* @param {!Event} _e Click event to handle.
* @public
*/
onClick(_e: Event): void;
}
interface ICollapsibleToolboxItem extends Blockly.ISelectableToolboxItem {
/**
* Gets any children toolbox items. (ex. Gets the subcategories)
* @return {!Array<!Blockly.IToolboxItem>} The child toolbox items.
*/
getChildToolboxItems(): Blockly.IToolboxItem[];
/**
* Whether the toolbox item is expanded to show its child subcategories.
* @return {boolean} True if the toolbox item shows its children, false if it
* is collapsed.
* @public
*/
isExpanded(): boolean;
/**
* Toggles whether or not the toolbox item is expanded.
* @public
*/
toggleExpanded: any /*missing*/;
}
}
declare module Blockly {
class ASTNode extends ASTNode__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class ASTNode__Class {
/**
* Class for an AST node.
* It is recommended that you use one of the createNode methods instead of
* creating a node directly.
* @param {string} type The type of the location.
* Must be in Blockly.ASTNode.types.
* @param {!Blockly.IASTNodeLocation} location The position in the AST.
* @param {!Blockly.ASTNode.Params=} opt_params Optional dictionary of options.
* @constructor
*/
constructor(type: string, location: Blockly.IASTNodeLocation, opt_params?: Blockly.ASTNode.Params);
/**
* Gets the value pointed to by this node.
* It is the callers responsibility to check the node type to figure out what
* type of object they get back from this.
* @return {!Blockly.IASTNodeLocation} The current field, connection, workspace, or
* block the cursor is on.
*/
getLocation(): Blockly.IASTNodeLocation;
/**
* The type of the current location.
* One of Blockly.ASTNode.types
* @return {string} The type of the location.
*/
getType(): string;
/**
* The coordinate on the workspace.
* @return {Blockly.utils.Coordinate} The workspace coordinate or null if the
* location is not a workspace.
*/
getWsCoordinate(): Blockly.utils.Coordinate;
/**
* Whether the node points to a connection.
* @return {boolean} [description]
* @package
*/
isConnection(): boolean;
/**
* Finds the source block of the location of this node.
* @return {Blockly.Block} The source block of the location, or null if the node
* is of type workspace.
*/
getSourceBlock(): Blockly.Block;
/**
* Find the element to the right of the current element in the AST.
* @return {Blockly.ASTNode} An AST node that wraps the next field, connection,
* block, or workspace. Or null if there is no node to the right.
*/
next(): Blockly.ASTNode;
/**
* Find the element one level below and all the way to the left of the current
* location.
* @return {Blockly.ASTNode} An AST node that wraps the next field, connection,
* workspace, or block. Or null if there is nothing below this node.
*/
in(): Blockly.ASTNode;
/**
* Find the element to the left of the current element in the AST.
* @return {Blockly.ASTNode} An AST node that wraps the previous field,
* connection, workspace or block. Or null if no node exists to the left.
* null.
*/
prev(): Blockly.ASTNode;
/**
* Find the next element that is one position above and all the way to the left
* of the current location.
* @return {Blockly.ASTNode} An AST node that wraps the next field, connection,
* workspace or block. Or null if we are at the workspace level.
*/
out(): Blockly.ASTNode;
}
}
declare module Blockly.ASTNode {
/**
* @typedef {{
* wsCoordinate: Blockly.utils.Coordinate
* }}
*/
interface Params {
wsCoordinate: Blockly.utils.Coordinate
}
/**
* Object holding different types for an AST node.
* @enum {string}
*/
enum types { FIELD, BLOCK, INPUT, OUTPUT, NEXT, PREVIOUS, STACK, WORKSPACE }
/**
* True to navigate to all fields. False to only navigate to clickable fields.
* @type {boolean}
*/
var NAVIGATE_ALL_FIELDS: boolean;
/**
* Create an AST node pointing to a field.
* @param {Blockly.Field} field The location of the AST node.
* @return {Blockly.ASTNode} An AST node pointing to a field.
*/
function createFieldNode(field: Blockly.Field): Blockly.ASTNode;
/**
* Creates an AST node pointing to a connection. If the connection has a parent
* input then create an AST node of type input that will hold the connection.
* @param {Blockly.Connection} connection This is the connection the node will
* point to.
* @return {Blockly.ASTNode} An AST node pointing to a connection.
*/
function createConnectionNode(connection: Blockly.Connection): Blockly.ASTNode;
/**
* Creates an AST node pointing to an input. Stores the input connection as the
* location.
* @param {Blockly.Input} input The input used to create an AST node.
* @return {Blockly.ASTNode} An AST node pointing to a input.
*/
function createInputNode(input: Blockly.Input): Blockly.ASTNode;
/**
* Creates an AST node pointing to a block.
* @param {Blockly.Block} block The block used to create an AST node.
* @return {Blockly.ASTNode} An AST node pointing to a block.
*/
function createBlockNode(block: Blockly.Block): Blockly.ASTNode;
/**
* Create an AST node of type stack. A stack, represented by its top block, is
* the set of all blocks connected to a top block, including the top block.
* @param {Blockly.Block} topBlock A top block has no parent and can be found
* in the list returned by workspace.getTopBlocks().
* @return {Blockly.ASTNode} An AST node of type stack that points to the top
* block on the stack.
*/
function createStackNode(topBlock: Blockly.Block): Blockly.ASTNode;
/**
* Creates an AST node pointing to a workspace.
* @param {!Blockly.Workspace} workspace The workspace that we are on.
* @param {Blockly.utils.Coordinate} wsCoordinate The position on the workspace
* for this node.
* @return {Blockly.ASTNode} An AST node pointing to a workspace and a position
* on the workspace.
*/
function createWorkspaceNode(workspace: Blockly.Workspace, wsCoordinate: Blockly.utils.Coordinate): Blockly.ASTNode;
/**
* Creates an AST node for the top position on a block.
* This is either an output connection, previous connection, or block.
* @param {!Blockly.Block} block The block to find the top most AST node on.
* @return {Blockly.ASTNode} The AST node holding the top most position on the
* block.
*/
function createTopNode(block: Blockly.Block): Blockly.ASTNode;
}
declare module Blockly {
class BasicCursor extends BasicCursor__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class BasicCursor__Class extends Blockly.Cursor__Class {
/**
* Class for a basic cursor.
* This will allow the user to get to all nodes in the AST by hitting next or
* previous.
* @constructor
* @extends {Blockly.Cursor}
*/
constructor();
/**
* Uses pre order traversal to navigate the Blockly AST. This will allow
* a user to easily navigate the entire Blockly AST without having to go in
* and out levels on the tree.
* @param {Blockly.ASTNode} node The current position in the AST.
* @param {!function(Blockly.ASTNode) : boolean} isValid A function true/false
* depending on whether the given node should be traversed.
* @return {Blockly.ASTNode} The next node in the traversal.
* @protected
*/
getNextNode_(node: Blockly.ASTNode, isValid: { (_0: Blockly.ASTNode): boolean }): Blockly.ASTNode;
/**
* Reverses the pre order traversal in order to find the previous node. This
* will allow a user to easily navigate the entire Blockly AST without having to
* go in and out levels on the tree.
* @param {Blockly.ASTNode} node The current position in the AST.
* @param {!function(Blockly.ASTNode) : boolean} isValid A function true/false
* depending on whether the given node should be traversed.
* @return {Blockly.ASTNode} The previous node in the traversal or null if no
* previous node exists.
* @protected
*/
getPreviousNode_(node: Blockly.ASTNode, isValid: { (_0: Blockly.ASTNode): boolean }): Blockly.ASTNode;
/**
* Decides what nodes to traverse and which ones to skip. Currently, it
* skips output, stack and workspace nodes.
* @param {Blockly.ASTNode} node The AST node to check whether it is valid.
* @return {boolean} True if the node should be visited, false otherwise.
* @protected
*/
validNode_(node: Blockly.ASTNode): boolean;
}
}
declare module Blockly.BasicCursor {
/**
* Name used for registering a basic cursor.
* @const {string}
*/
var registrationName: any /*missing*/;
}
declare module Blockly {
class Cursor extends Cursor__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Cursor__Class extends Blockly.Marker__Class {
/**
* Class for a cursor.
* A cursor controls how a user navigates the Blockly AST.
* @constructor
* @extends {Blockly.Marker}
*/
constructor();
/**
* Find the next connection, field, or block.
* @return {Blockly.ASTNode} The next element, or null if the current node is
* not set or there is no next value.
* @public
*/
next(): Blockly.ASTNode;
/**
* Find the in connection or field.
* @return {Blockly.ASTNode} The in element, or null if the current node is
* not set or there is no in value.
* @public
*/
in(): Blockly.ASTNode;
/**
* Find the previous connection, field, or block.
* @return {Blockly.ASTNode} The previous element, or null if the current node
* is not set or there is no previous value.
* @public
*/
prev(): Blockly.ASTNode;
/**
* Find the out connection, field, or block.
* @return {Blockly.ASTNode} The out element, or null if the current node is
* not set or there is no out value.
* @public
*/
out(): Blockly.ASTNode;
}
}
declare module Blockly {
class Marker extends Marker__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Marker__Class {
/**
* Class for a marker.
* This is used in keyboard navigation to save a location in the Blockly AST.
* @constructor
*/
constructor();
/**
* The colour of the marker.
* @type {?string}
*/
colour: string;
/**
* The type of the marker.
* @type {string}
*/
type: string;
/**
* Sets the object in charge of drawing the marker.
* @param {Blockly.blockRendering.MarkerSvg} drawer The object in charge of
* drawing the marker.
*/
setDrawer(drawer: Blockly.blockRendering.MarkerSvg): void;
/**
* Get the current drawer for the marker.
* @return {Blockly.blockRendering.MarkerSvg} The object in charge of drawing
* the marker.
*/
getDrawer(): Blockly.blockRendering.MarkerSvg;
/**
* Gets the current location of the marker.
* @return {Blockly.ASTNode} The current field, connection, or block the marker
* is on.
*/
getCurNode(): Blockly.ASTNode;
/**
* 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 {Blockly.ASTNode} newNode The new location of the marker.
*/
setCurNode(newNode: Blockly.ASTNode): void;
/**
* Redraw the current marker.
* @package
*/
draw(): void;
/**
* Hide the marker SVG.
*/
hide(): void;
/**
* Dispose of this marker.
*/
dispose(): void;
}
}
declare module Blockly {
class TabNavigateCursor extends TabNavigateCursor__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class TabNavigateCursor__Class extends Blockly.BasicCursor__Class {
/**
* A cursor for navigating between tab navigable fields.
* @constructor
* @extends {Blockly.BasicCursor}
*/
constructor();
}
}
declare module Blockly {
class ToolboxCategory extends ToolboxCategory__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class ToolboxCategory__Class extends Blockly.ToolboxItem__Class implements Blockly.ISelectableToolboxItem {
/**
* Class for a category in a toolbox.
* @param {!Blockly.utils.toolbox.CategoryInfo} categoryDef The information needed
* to create a category in the toolbox.
* @param {!Blockly.IToolbox} toolbox The parent toolbox for the category.
* @param {Blockly.ICollapsibleToolboxItem=} opt_parent The parent category or null if
* the category does not have a parent.
* @constructor
* @extends {Blockly.ToolboxItem}
* @implements {Blockly.ISelectableToolboxItem}
*/
constructor(categoryDef: Blockly.utils.toolbox.CategoryInfo, toolbox: Blockly.IToolbox, opt_parent?: Blockly.ICollapsibleToolboxItem);
/**
* The name that will be displayed on the category.
* @type {string}
* @protected
*/
name_: string;
/**
* The colour of the category.
* @type {string}
* @protected
*/
colour_: string;
/**
* The html container for the category.
* @type {?Element}
* @protected
*/
htmlDiv_: Element;
/**
* The html element for the category row.
* @type {?Element}
* @protected
*/
rowDiv_: Element;
/**
* The html element that holds children elements of the category row.
* @type {?Element}
* @protected
*/
rowContents_: Element;
/**
* The html element for the toolbox icon.
* @type {?Element}
* @protected
*/
iconDom_: Element;
/**
* The html element for the toolbox label.
* @type {?Element}
* @protected
*/
labelDom_: Element;
/**
* All the css class names that are used to create a category.
* @type {!Blockly.ToolboxCategory.CssConfig}
* @protected
*/
cssConfig_: Blockly.ToolboxCategory.CssConfig;
/**
* True if the category is meant to be hidden, false otherwise.
* @type {boolean}
* @protected
*/
isHidden_: boolean;
/**
* True if this category is disabled, false otherwise.
* @type {boolean}
* @protected
*/
isDisabled_: boolean;
/**
* The flyout items for this category.
* @type {string|!Blockly.utils.toolbox.FlyoutItemInfoArray}
* @protected
*/
flyoutItems_: string|Blockly.utils.toolbox.FlyoutItemInfoArray;
/**
* Creates an object holding the default classes for a category.
* @return {!Blockly.ToolboxCategory.CssConfig} The configuration object holding
* all the CSS classes for a category.
* @protected
*/
makeDefaultCssConfig_(): Blockly.ToolboxCategory.CssConfig;
/**
* Parses the contents array depending on if the category is a dynamic category,
* or if its contents are meant to be shown in the flyout.
* @param {!Blockly.utils.toolbox.CategoryInfo} categoryDef The information needed
* to create a category.
* @protected
*/
parseContents_(categoryDef: Blockly.utils.toolbox.CategoryInfo): void;
/**
* Creates the DOM for the category.
* @return {!Element} The parent element for the category.
* @protected
*/
createDom_(): Element;
/**
* Creates the container that holds the row and any subcategories.
* @return {!Element} The div that holds the icon and the label.
* @protected
*/
createContainer_(): Element;
/**
* Creates the parent of the contents container. All clicks will happen on this
* div.
* @return {!Element} The div that holds the contents container.
* @protected
*/
createRowContainer_(): Element;
/**
* Creates the container for the label and icon.
* This is necessary so we can set all subcategory pointer events to none.
* @return {!Element} The div that holds the icon and the label.
* @protected
*/
createRowContentsContainer_(): Element;
/**
* Creates the span that holds the category icon.
* @return {!Element} The span that holds the category icon.
* @protected
*/
createIconDom_(): Element;
/**
* Creates the span that holds the category label.
* This should have an ID for accessibility purposes.
* @param {string} name The name of the category.
* @return {!Element} The span that holds the category label.
* @protected
*/
createLabelDom_(name: string): Element;
/**
* Updates the colour for this category.
* @public
*/
refreshTheme(): void;
/**
* Add the strip of colour to the toolbox category.
* @param {string} colour The category colour.
* @protected
*/
addColourBorder_(colour: string): void;
/**
* Gets either the colour or the style for a category.
* @param {!Blockly.utils.toolbox.CategoryInfo} categoryDef The object holding
* information on the category.
* @return {string} The hex colour for the category.
* @protected
*/
getColour_(categoryDef: Blockly.utils.toolbox.CategoryInfo): string;
/**
* Gets the HTML element that is clickable.
* The parent toolbox element receives clicks. The parent toolbox will add an ID
* to this element so it can pass the onClick event to the correct toolboxItem.
* @return {!Element} The HTML element that receives clicks.
* @public
*/
getClickTarget(): Element;
/**
* Adds appropriate classes to display an open icon.
* @param {?Element} iconDiv The div that holds the icon.
* @protected
*/
openIcon_(iconDiv: Element): void;
/**
* Adds appropriate classes to display a closed icon.
* @param {?Element} iconDiv The div that holds the icon.
* @protected
*/
closeIcon_(iconDiv: Element): void;
/**
* Sets whether the category is visible or not.
* For a category to be visible its parent category must also be expanded.
* @param {boolean} isVisible True if category should be visible.
* @protected
*/
setVisible_(isVisible: boolean): void;
/**
* Hide the category.
*/
hide(): void;
/**
* Show the category. Category will only appear if its parent category is also
* expanded.
*/
show(): void;
/**
* Whether the category is visible.
* A category is only visible if all of its ancestors are expanded and isHidden_ is false.
* @return {boolean} True if the category is visible, false otherwise.
* @public
*/
isVisible(): boolean;
/**
* Whether all ancestors of a category (parent and parent's parent, etc.) are expanded.
* @return {boolean} True only if every ancestor is expanded
* @protected
*/
allAncestorsExpanded_(): boolean;
/**
* Handles when the toolbox item is clicked.
* @param {!Event} _e Click event to handle.
* @public
*/
onClick(_e: Event): void;
/**
* Sets the current category as selected.
* @param {boolean} isSelected True if this category is selected, false
* otherwise.
* @public
*/
setSelected(isSelected: boolean): void;
/**
* Sets whether the category is disabled.
* @param {boolean} isDisabled True to disable the category, false otherwise.
*/
setDisabled(isDisabled: boolean): void;
/**
* Gets the name of the category. Used for emitting events.
* @return {string} The name of the toolbox item.
* @public
*/
getName(): string;
/**
* Gets the contents of the category. These are items that are meant to be
* displayed in the flyout.
* @return {!Blockly.utils.toolbox.FlyoutItemInfoArray|string} The definition
* of items to be displayed in the flyout.
* @public
*/
getContents(): Blockly.utils.toolbox.FlyoutItemInfoArray|string;
/**
* Updates the contents to be displayed in the flyout.
* If the flyout is open when the contents are updated, refreshSelection on the
* toolbox must also be called.
* @param {!Blockly.utils.toolbox.FlyoutDefinition|string} contents The contents
* to be displayed in the flyout. A string can be supplied to create a
* dynamic category.
* @public
*/
updateFlyoutContents(contents: Blockly.utils.toolbox.FlyoutDefinition|string): void;
}
}
declare module Blockly.ToolboxCategory {
/**
* All the CSS class names that are used to create a category.
* @typedef {{
* container:(string|undefined),
* row:(string|undefined),
* rowcontentcontainer:(string|undefined),
* icon:(string|undefined),
* label:(string|undefined),
* selected:(string|undefined),
* openicon:(string|undefined),
* closedicon:(string|undefined)
* }}
*/
interface CssConfig {
container: string|any /*undefined*/;
row: string|any /*undefined*/;
rowcontentcontainer: string|any /*undefined*/;
icon: string|any /*undefined*/;
label: string|any /*undefined*/;
selected: string|any /*undefined*/;
openicon: string|any /*undefined*/;
closedicon: string|any /*undefined*/
}
/**
* Name used for registering a toolbox category.
* @const {string}
*/
var registrationName: any /*missing*/;
/**
* The number of pixels to move the category over at each nested level.
* @type {number}
*/
var nestedPadding: number;
/**
* The width in pixels of the strip of colour next to each category.
* @type {number}
*/
var borderWidth: number;
/**
* The default colour of the category. This is used as the background colour of
* the category when it is selected.
* @type {string}
*/
var defaultBackgroundColour: string;
}
declare module Blockly {
class CollapsibleToolboxCategory extends CollapsibleToolboxCategory__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class CollapsibleToolboxCategory__Class extends Blockly.ToolboxCategory__Class implements Blockly.ICollapsibleToolboxItem {
/**
* Class for a category in a toolbox that can be collapsed.
* @param {!Blockly.utils.toolbox.CategoryInfo} categoryDef The information needed
* to create a category in the toolbox.
* @param {!Blockly.IToolbox} toolbox The parent toolbox for the category.
* @param {Blockly.ICollapsibleToolboxItem=} opt_parent The parent category or null if
* the category does not have a parent.
* @constructor
* @extends {Blockly.ToolboxCategory}
* @implements {Blockly.ICollapsibleToolboxItem}
*/
constructor(categoryDef: Blockly.utils.toolbox.CategoryInfo, toolbox: Blockly.IToolbox, opt_parent?: Blockly.ICollapsibleToolboxItem);
/**
* Container for any child categories.
* @type {?Element}
* @protected
*/
subcategoriesDiv_: Element;
/**
* Whether or not the category should display its subcategories.
* @type {boolean}
* @protected
*/
expanded_: boolean;
/**
* The child toolbox items for this category.
* @type {!Array<!Blockly.ToolboxItem>}
* @protected
*/
toolboxItems_: Blockly.ToolboxItem[];
/**
* Create the DOM for all subcategories.
* @param {!Array<!Blockly.ToolboxItem>} subcategories The subcategories.
* @return {!Element} The div holding all the subcategories.
* @protected
*/
createSubCategoriesDom_(subcategories: Blockly.ToolboxItem[]): Element;
/**
* Opens or closes the current category.
* @param {boolean} isExpanded True to expand the category, false to close.
* @public
*/
setExpanded(isExpanded: boolean): void;
/**
* Whether the category is expanded to show its child subcategories.
* @return {boolean} True if the toolbox item shows its children, false if it
* is collapsed.
* @public
*/
isExpanded(): boolean;
/**
* Toggles whether or not the category is expanded.
* @public
*/
toggleExpanded(): void;
/**
* Gets any children toolbox items. (ex. Gets the subcategories)
* @return {!Array<!Blockly.IToolboxItem>} The child toolbox items.
*/
getChildToolboxItems(): Blockly.IToolboxItem[];
}
}
declare module Blockly.CollapsibleToolboxCategory {
/**
* All the CSS class names that are used to create a collapsible
* category. This is all the properties from the regular category plus contents.
* @typedef {{
* container:?string,
* row:?string,
* rowcontentcontainer:?string,
* icon:?string,
* label:?string,
* selected:?string,
* openicon:?string,
* closedicon:?string,
* contents:?string
* }}
*/
interface CssConfig {
container: string;
row: string;
rowcontentcontainer: string;
icon: string;
label: string;
selected: string;
openicon: string;
closedicon: string;
contents: string
}
/**
* Name used for registering a collapsible toolbox category.
* @const {string}
*/
var registrationName: any /*missing*/;
}
declare module Blockly {
class ToolboxSeparator extends ToolboxSeparator__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class ToolboxSeparator__Class extends Blockly.ToolboxItem__Class implements Blockly.IToolboxItem {
/**
* Class for a toolbox separator. This is the thin visual line that appears on
* the toolbox. This item is not interactable.
* @param {!Blockly.utils.toolbox.SeparatorInfo} separatorDef The information
* needed to create a separator.
* @param {!Blockly.IToolbox} toolbox The parent toolbox for the separator.
* @constructor
* @extends {Blockly.ToolboxItem}
* @implements {Blockly.IToolboxItem}
*/
constructor(separatorDef: Blockly.utils.toolbox.SeparatorInfo, toolbox: Blockly.IToolbox);
/**
* All the CSS class names that are used to create a separator.
* @type {!Blockly.ToolboxSeparator.CssConfig}
* @protected
*/
cssConfig_: Blockly.ToolboxSeparator.CssConfig;
/**
* Creates the DOM for a separator.
* @return {!Element} The parent element for the separator.
* @protected
*/
createDom_(): Element;
}
}
declare module Blockly.ToolboxSeparator {
/**
* All the CSS class names that are used to create a separator.
* @typedef {{
* container:(string|undefined)
* }}
*/
interface CssConfig {
container: string|any /*undefined*/
}
/**
* Name used for registering a toolbox separator.
* @const {string}
*/
var registrationName: any /*missing*/;
}
declare module Blockly {
class Toolbox extends Toolbox__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Toolbox__Class extends Blockly.DeleteArea__Class implements Blockly.IAutoHideable, Blockly.IKeyboardAccessible, Blockly.IStyleable, Blockly.IToolbox {
/**
* Class for a Toolbox.
* Creates the toolbox's DOM.
* @param {!Blockly.WorkspaceSvg} workspace The workspace in which to create new
* blocks.
* @constructor
* @implements {Blockly.IAutoHideable}
* @implements {Blockly.IKeyboardAccessible}
* @implements {Blockly.IStyleable}
* @implements {Blockly.IToolbox}
* @extends {Blockly.DeleteArea}
*/
constructor(workspace: Blockly.WorkspaceSvg);
/**
* The workspace this toolbox is on.
* @type {!Blockly.WorkspaceSvg}
* @protected
*/
workspace_: Blockly.WorkspaceSvg;
/**
* The unique id for this component that is used to register with the
* ComponentManager.
* @type {string}
*/
id: string;
/**
* The JSON describing the contents of this toolbox.
* @type {!Blockly.utils.toolbox.ToolboxInfo}
* @protected
*/
toolboxDef_: Blockly.utils.toolbox.ToolboxInfo;
/**
* The html container for the toolbox.
* @type {?Element}
*/
HtmlDiv: Element;
/**
* The html container for the contents of a toolbox.
* @type {?Element}
* @protected
*/
contentsDiv_: Element;
/**
* Whether the Toolbox is visible.
* @type {boolean}
* @protected
*/
isVisible_: boolean;
/**
* The list of items in the toolbox.
* @type {!Array<!Blockly.IToolboxItem>}
* @protected
*/
contents_: Blockly.IToolboxItem[];
/**
* The width of the toolbox.
* @type {number}
* @protected
*/
width_: number;
/**
* The height of the toolbox.
* @type {number}
* @protected
*/
height_: number;
/**
* Is RTL vs LTR.
* @type {boolean}
*/
RTL: boolean;
/**
* A map from toolbox item IDs to toolbox items.
* @type {!Object<string, !Blockly.IToolboxItem>}
* @protected
*/
contentMap_: { [key: string]: Blockly.IToolboxItem };
/**
* Position of the toolbox and flyout relative to the workspace.
* @type {!Blockly.utils.toolbox.Position}
*/
toolboxPosition: Blockly.utils.toolbox.Position;
/**
* The currently selected item.
* @type {?Blockly.ISelectableToolboxItem}
* @protected
*/
selectedItem_: Blockly.ISelectableToolboxItem;
/**
* The previously selected item.
* @type {?Blockly.ISelectableToolboxItem}
* @protected
*/
previouslySelectedItem_: Blockly.ISelectableToolboxItem;
/**
* Array holding info needed to unbind event handlers.
* Used for disposing.
* Ex: [[node, name, func], [node, name, func]].
* @type {!Array<!Blockly.browserEvents.Data>}
* @protected
*/
boundEvents_: Blockly.browserEvents.Data[];
/**
* Handles the given keyboard shortcut.
* @param {!Blockly.ShortcutRegistry.KeyboardShortcut} _shortcut The shortcut to be handled.
* @return {boolean} True if the shortcut has been handled, false otherwise.
* @public
*/
onShortcut(_shortcut: Blockly.ShortcutRegistry.KeyboardShortcut): boolean;
/**
* Initializes the toolbox
* @public
*/
init(): void;
/**
* Creates the DOM for the toolbox.
* @param {!Blockly.WorkspaceSvg} workspace The workspace this toolbox is on.
* @return {!Element} The HTML container for the toolbox.
* @protected
*/
createDom_(workspace: Blockly.WorkspaceSvg): Element;
/**
* Creates the container div for the toolbox.
* @return {!Element} The HTML container for the toolbox.
* @protected
*/
createContainer_(): Element;
/**
* Creates the container for all the contents in the toolbox.
* @return {!Element} The HTML container for the toolbox contents.
* @protected
*/
createContentsContainer_(): Element;
/**
* Adds event listeners to the toolbox container div.
* @param {!Element} container The HTML container for the toolbox.
* @param {!Element} contentsContainer The HTML container for the contents
* of the toolbox.
* @protected
*/
attachEvents_(container: Element, contentsContainer: Element): void;
/**
* Handles on click events for when the toolbox or toolbox items are clicked.
* @param {!Event} e Click event to handle.
* @protected
*/
onClick_(e: Event): void;
/**
* Handles key down events for the toolbox.
* @param {!KeyboardEvent} e The key down event.
* @protected
*/
onKeyDown_(e: KeyboardEvent): void;
/**
* Creates the flyout based on the toolbox layout.
* @return {!Blockly.IFlyout} The flyout for the toolbox.
* @throws {Error} If missing a require for `Blockly.HorizontalFlyout`,
* `Blockly.VerticalFlyout`, and no flyout plugin is specified.
* @protected
*/
createFlyout_(): Blockly.IFlyout;
/**
* Fills the toolbox with new toolbox items and removes any old contents.
* @param {!Blockly.utils.toolbox.ToolboxInfo} toolboxDef Object holding information
* for creating a toolbox.
* @package
*/
render(toolboxDef: Blockly.utils.toolbox.ToolboxInfo): void;
/**
* Adds all the toolbox items to the toolbox.
* @param {!Array<!Blockly.utils.toolbox.ToolboxItemInfo>} toolboxDef Array
* holding objects containing information on the contents of the toolbox.
* @protected
*/
renderContents_(toolboxDef: Blockly.utils.toolbox.ToolboxItemInfo[]): void;
/**
* Adds an item to the toolbox.
* @param {!Blockly.IToolboxItem} toolboxItem The item in the toolbox.
* @protected
*/
addToolboxItem_(toolboxItem: Blockly.IToolboxItem): void;
/**
* Gets the items in the toolbox.
* @return {!Array<!Blockly.IToolboxItem>} The list of items in the toolbox.
* @public
*/
getToolboxItems(): Blockly.IToolboxItem[];
/**
* Adds a style on the toolbox. Usually used to change the cursor.
* @param {string} style The name of the class to add.
* @package
*/
addStyle(style: string): void;
/**
* Removes a style from the toolbox. Usually used to change the cursor.
* @param {string} style The name of the class to remove.
* @package
*/
removeStyle(style: string): void;
/**
* Returns the bounding rectangle of the drag target area in pixel units
* relative to viewport.
* @return {?Blockly.utils.Rect} The component's bounding box. Null if drag
* target area should be ignored.
*/
getClientRect(): Blockly.utils.Rect;
/**
* Adds or removes the CSS style of the cursor over the toolbox based whether
* the block or bubble over it is expected to be deleted if dropped (using the
* internal this.wouldDelete_ property).
* @param {boolean} addStyle Whether the style should be added or removed.
* @protected
*/
updateCursorDeleteStyle_(addStyle: boolean): void;
/**
* Gets the toolbox item with the given ID.
* @param {string} id The ID of the toolbox item.
* @return {?Blockly.IToolboxItem} The toolbox item with the given ID, or null
* if no item exists.
* @public
*/
getToolboxItemById(id: string): Blockly.IToolboxItem;
/**
* Gets the width of the toolbox.
* @return {number} The width of the toolbox.
* @public
*/
getWidth(): number;
/**
* Gets the height of the toolbox.
* @return {number} The width of the toolbox.
* @public
*/
getHeight(): number;
/**
* Gets the toolbox flyout.
* @return {?Blockly.IFlyout} The toolbox flyout.
* @public
*/
getFlyout(): Blockly.IFlyout;
/**
* Gets the workspace for the toolbox.
* @return {!Blockly.WorkspaceSvg} The parent workspace for the toolbox.
* @public
*/
getWorkspace(): Blockly.WorkspaceSvg;
/**
* Gets the selected item.
* @return {?Blockly.ISelectableToolboxItem} The selected item, or null if no item is
* currently selected.
* @public
*/
getSelectedItem(): Blockly.ISelectableToolboxItem;
/**
* Gets the previously selected item.
* @return {?Blockly.ISelectableToolboxItem} The previously selected item, or null if no
* item was previously selected.
* @public
*/
getPreviouslySelectedItem(): Blockly.ISelectableToolboxItem;
/**
* Gets whether or not the toolbox is horizontal.
* @return {boolean} True if the toolbox is horizontal, false if the toolbox is
* vertical.
* @public
*/
isHorizontal(): boolean;
/**
* Positions the toolbox based on whether it is a horizontal toolbox and whether
* the workspace is in rtl.
* @public
*/
position(): void;
/**
* Handles resizing the toolbox when a toolbox item resizes.
* @package
*/
handleToolboxItemResize(): void;
/**
* Unhighlights any previously selected item.
* @public
*/
clearSelection(): void;
/**
* Updates the category colours and background colour of selected categories.
* @package
*/
refreshTheme(): void;
/**
* Updates the flyout's content without closing it. Should be used in response
* to a change in one of the dynamic categories, such as variables or
* procedures.
* @public
*/
refreshSelection(): void;
/**
* Shows or hides the toolbox.
* @param {boolean} isVisible True if toolbox should be visible.
* @public
*/
setVisible(isVisible: boolean): void;
/**
* Hides the component. Called in Blockly.hideChaff.
* @param {boolean} onlyClosePopups Whether only popups should be closed.
* Flyouts should not be closed if this is true.
*/
autoHide(onlyClosePopups: boolean): void;
/**
* Sets the given item as selected.
* No-op if the item is not selectable.
* @param {?Blockly.IToolboxItem} newItem The toolbox item to select.
* @public
*/
setSelectedItem(newItem: Blockly.IToolboxItem): void;
/**
* Decides whether the old item should be deselected.
* @param {?Blockly.ISelectableToolboxItem} oldItem The previously selected
* toolbox item.
* @param {?Blockly.ISelectableToolboxItem} newItem The newly selected toolbox
* item.
* @return {boolean} True if the old item should be deselected, false otherwise.
* @protected
*/
shouldDeselectItem_(oldItem: Blockly.ISelectableToolboxItem, newItem: Blockly.ISelectableToolboxItem): boolean;
/**
* Decides whether the new item should be selected.
* @param {?Blockly.ISelectableToolboxItem} oldItem The previously selected
* toolbox item.
* @param {?Blockly.ISelectableToolboxItem} newItem The newly selected toolbox
* item.
* @return {boolean} True if the new item should be selected, false otherwise.
* @protected
*/
shouldSelectItem_(oldItem: Blockly.ISelectableToolboxItem, newItem: Blockly.ISelectableToolboxItem): boolean;
/**
* Deselects the given item, marks it as unselected, and updates aria state.
* @param {!Blockly.ISelectableToolboxItem} item The previously selected
* toolbox item which should be deselected.
* @protected
*/
deselectItem_(item: Blockly.ISelectableToolboxItem): void;
/**
* Selects the given item, marks it selected, and updates aria state.
* @param {?Blockly.ISelectableToolboxItem} oldItem The previously selected
* toolbox item.
* @param {!Blockly.ISelectableToolboxItem} newItem The newly selected toolbox
* item.
* @protected
*/
selectItem_(oldItem: Blockly.ISelectableToolboxItem, newItem: Blockly.ISelectableToolboxItem): void;
/**
* Selects the toolbox item by its position in the list of toolbox items.
* @param {number} position The position of the item to select.
* @public
*/
selectItemByPosition(position: number): void;
/**
* Decides whether to hide or show the flyout depending on the selected item.
* @param {?Blockly.ISelectableToolboxItem} oldItem The previously selected toolbox item.
* @param {?Blockly.ISelectableToolboxItem} newItem The newly selected toolbox item.
* @protected
*/
updateFlyout_(oldItem: Blockly.ISelectableToolboxItem, newItem: Blockly.ISelectableToolboxItem): void;
/**
* Disposes of this toolbox.
* @public
*/
dispose(): void;
}
}
declare module Blockly {
class ToolboxItem extends ToolboxItem__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class ToolboxItem__Class implements Blockly.IToolboxItem {
/**
* Class for an item in the toolbox.
* @param {!Blockly.utils.toolbox.ToolboxItemInfo} toolboxItemDef The JSON defining the
* toolbox item.
* @param {!Blockly.IToolbox} toolbox The toolbox that holds the toolbox item.
* @param {Blockly.ICollapsibleToolboxItem=} opt_parent The parent toolbox item
* or null if the category does not have a parent.
* @constructor
* @implements {Blockly.IToolboxItem}
*/
constructor(toolboxItemDef: Blockly.utils.toolbox.ToolboxItemInfo, toolbox: Blockly.IToolbox, opt_parent?: Blockly.ICollapsibleToolboxItem);
/**
* The id for the category.
* @type {string}
* @protected
*/
id_: string;
/**
* The parent of the category.
* @type {?Blockly.ICollapsibleToolboxItem}
* @protected
*/
parent_: Blockly.ICollapsibleToolboxItem;
/**
* The level that the category is nested at.
* @type {number}
* @protected
*/
level_: number;
/**
* The JSON definition of the toolbox item.
* @type {!Blockly.utils.toolbox.ToolboxItemInfo}
* @protected
*/
toolboxItemDef_: Blockly.utils.toolbox.ToolboxItemInfo;
/**
* The toolbox this category belongs to.
* @type {!Blockly.IToolbox}
* @protected
*/
parentToolbox_: Blockly.IToolbox;
/**
* The workspace of the parent toolbox.
* @type {!Blockly.WorkspaceSvg}
* @protected
*/
workspace_: Blockly.WorkspaceSvg;
/**
* Initializes the toolbox item.
* This includes creating the DOM and updating the state of any items based
* on the info object.
* @public
*/
init(): void;
/**
* Gets the div for the toolbox item.
* @return {?Element} The div for the toolbox item.
* @public
*/
getDiv(): Element;
/**
* Gets a unique identifier for this toolbox item.
* @return {string} The ID for the toolbox item.
* @public
*/
getId(): string;
/**
* Gets the parent if the toolbox item is nested.
* @return {?Blockly.IToolboxItem} The parent toolbox item, or null if
* this toolbox item is not nested.
* @public
*/
getParent(): Blockly.IToolboxItem;
/**
* Gets the nested level of the category.
* @return {number} The nested level of the category.
* @package
*/
getLevel(): number;
/**
* Whether the toolbox item is selectable.
* @return {boolean} True if the toolbox item can be selected.
* @public
*/
isSelectable(): boolean;
/**
* Whether the toolbox item is collapsible.
* @return {boolean} True if the toolbox item is collapsible.
* @public
*/
isCollapsible(): boolean;
/**
* Dispose of this toolbox item. No-op by default.
* @public
*/
dispose(): void;
}
}
declare module Blockly.utils.aria {
/**
* ARIA role values.
* Copied from Closure's goog.a11y.aria.Role
* @enum {string}
*/
enum Role { GRID, GRIDCELL, GROUP, LISTBOX, MENU, MENUITEM, MENUITEMCHECKBOX, OPTION, PRESENTATION, ROW, TREE, TREEITEM }
/**
* ARIA states and properties.
* Copied from Closure's goog.a11y.aria.State
* @enum {string}
*/
enum State { ACTIVEDESCENDANT, COLCOUNT, DISABLED, EXPANDED, INVALID, LABEL, LABELLEDBY, LEVEL, ORIENTATION, POSINSET, ROWCOUNT, SELECTED, SETSIZE, VALUEMAX, VALUEMIN }
/**
* Sets the role of an element.
*
* Similar to Closure's goog.a11y.aria
*
* @param {!Element} element DOM node to set role of.
* @param {!Blockly.utils.aria.Role} roleName Role name.
*/
function setRole(element: Element, roleName: Blockly.utils.aria.Role): void;
/**
* Sets the state or property of an element.
* Copied from Closure's goog.a11y.aria
* @param {!Element} element DOM node where we set state.
* @param {!Blockly.utils.aria.State} stateName State attribute being set.
* Automatically adds prefix 'aria-' to the state name if the attribute is
* not an extra attribute.
* @param {string|boolean|number|!Array<string>} value Value
* for the state attribute.
*/
function setState(element: Element, stateName: Blockly.utils.aria.State, value: string|boolean|number|string[]): void;
}
declare module Blockly.utils.colour {
/**
* Parses a colour from a string.
* .parse('red') -> '#ff0000'
* .parse('#f00') -> '#ff0000'
* .parse('#ff0000') -> '#ff0000'
* .parse('0xff0000') -> '#ff0000'
* .parse('rgb(255, 0, 0)') -> '#ff0000'
* @param {string|number} str Colour in some CSS format.
* @return {?string} A string containing a hex representation of the colour,
* or null if can't be parsed.
*/
function parse(str: string|number): string;
/**
* Converts a colour from RGB to hex representation.
* @param {number} r Amount of red, int between 0 and 255.
* @param {number} g Amount of green, int between 0 and 255.
* @param {number} b Amount of blue, int between 0 and 255.
* @return {string} Hex representation of the colour.
*/
function rgbToHex(r: number, g: number, b: number): string;
/**
* Converts a colour to RGB.
* @param {string} colour String representing colour in any
* colour format ('#ff0000', 'red', '0xff000', etc).
* @return {!Array<number>} RGB representation of the colour.
*/
function hexToRgb(colour: string): number[];
/**
* Converts an HSV triplet to hex representation.
* @param {number} h Hue value in [0, 360].
* @param {number} s Saturation value in [0, 1].
* @param {number} v Brightness in [0, 255].
* @return {string} Hex representation of the colour.
*/
function hsvToHex(h: number, s: number, v: number): string;
/**
* Blend two colours together, using the specified factor to indicate the
* weight given to the first colour.
* @param {string} colour1 First colour.
* @param {string} colour2 Second colour.
* @param {number} factor The weight to be given to colour1 over colour2.
* Values should be in the range [0, 1].
* @return {?string} Combined colour represented in hex.
*/
function blend(colour1: string, colour2: string, factor: number): string;
/**
* A map that contains the 16 basic colour keywords as defined by W3C:
* https://www.w3.org/TR/2018/REC-css-color-3-20180619/#html4
* The keys of this map are the lowercase "readable" names of the colours,
* while the values are the "hex" values.
*
* @type {!Object<string, string>}
*/
var names: { [key: string]: string };
}
declare module Blockly.utils {
class Coordinate extends Coordinate__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Coordinate__Class {
/**
* Class for representing coordinates and positions.
* @param {number} x Left.
* @param {number} y Top.
* @struct
* @constructor
*/
constructor(x: number, y: number);
/**
* X-value
* @type {number}
*/
x: number;
/**
* Y-value
* @type {number}
*/
y: number;
/**
* Creates a new copy of this coordinate.
* @return {!Blockly.utils.Coordinate} A copy of this coordinate.
*/
clone(): Blockly.utils.Coordinate;
/**
* Scales this coordinate by the given scale factor.
* @param {number} s The scale factor to use for both x and y dimensions.
* @return {!Blockly.utils.Coordinate} This coordinate after scaling.
*/
scale(s: number): Blockly.utils.Coordinate;
/**
* Translates this coordinate by the given offsets.
* respectively.
* @param {number} tx The value to translate x by.
* @param {number} ty The value to translate y by.
* @return {!Blockly.utils.Coordinate} This coordinate after translating.
*/
translate(tx: number, ty: number): Blockly.utils.Coordinate;
}
}
declare module Blockly.utils.Coordinate {
/**
* Compares coordinates for equality.
* @param {?Blockly.utils.Coordinate} a A Coordinate.
* @param {?Blockly.utils.Coordinate} b A Coordinate.
* @return {boolean} True iff the coordinates are equal, or if both are null.
*/
function equals(a: Blockly.utils.Coordinate, b: Blockly.utils.Coordinate): boolean;
/**
* Returns the distance between two coordinates.
* @param {!Blockly.utils.Coordinate} a A Coordinate.
* @param {!Blockly.utils.Coordinate} b A Coordinate.
* @return {number} The distance between `a` and `b`.
*/
function distance(a: Blockly.utils.Coordinate, b: Blockly.utils.Coordinate): number;
/**
* Returns the magnitude of a coordinate.
* @param {!Blockly.utils.Coordinate} a A Coordinate.
* @return {number} The distance between the origin and `a`.
*/
function magnitude(a: Blockly.utils.Coordinate): number;
/**
* Returns the difference between two coordinates as a new
* Blockly.utils.Coordinate.
* @param {!Blockly.utils.Coordinate|!SVGPoint} a An x/y coordinate.
* @param {!Blockly.utils.Coordinate|!SVGPoint} b An x/y coordinate.
* @return {!Blockly.utils.Coordinate} A Coordinate representing the difference
* between `a` and `b`.
*/
function difference(a: Blockly.utils.Coordinate|SVGPoint, b: Blockly.utils.Coordinate|SVGPoint): Blockly.utils.Coordinate;
/**
* Returns the sum of two coordinates as a new Blockly.utils.Coordinate.
* @param {!Blockly.utils.Coordinate|!SVGPoint} a An x/y coordinate.
* @param {!Blockly.utils.Coordinate|!SVGPoint} b An x/y coordinate.
* @return {!Blockly.utils.Coordinate} A Coordinate representing the sum of
* the two coordinates.
*/
function sum(a: Blockly.utils.Coordinate|SVGPoint, b: Blockly.utils.Coordinate|SVGPoint): Blockly.utils.Coordinate;
}
declare module Blockly.utils.deprecation {
/**
* Warn developers that a function or property is deprecated.
* @param {string} name The name of the function or property.
* @param {string} deprecationDate The date of deprecation.
* Prefer 'month yyyy' or 'quarter yyyy' format.
* @param {string} deletionDate The date of deletion, in the same format as the
* deprecation date.
* @param {string=} opt_use The name of a function or property to use instead,
* if any.
* @package
*/
function warn(name: string, deprecationDate: string, deletionDate: string, opt_use?: string): void;
}
declare module Blockly.utils.dom {
/**
* Required name space for SVG elements.
* @const
*/
var SVG_NS: any /*missing*/;
/**
* Required name space for HTML elements.
* @const
*/
var HTML_NS: any /*missing*/;
/**
* Required name space for XLINK elements.
* @const
*/
var XLINK_NS: any /*missing*/;
/**
* Node type constants.
* https://developer.mozilla.org/en-US/docs/Web/API/Node/nodeType
* @enum {number}
*/
enum NodeType { ELEMENT_NODE, TEXT_NODE, COMMENT_NODE, DOCUMENT_POSITION_CONTAINED_BY }
/**
* Helper method for creating SVG elements.
* @param {string|Blockly.utils.Svg<T>} name Element's tag name.
* @param {!Object} attrs Dictionary of attribute names and values.
* @param {Element=} opt_parent Optional parent on which to append the element.
* @return {T} Newly created SVG element. The return type is {!SVGElement} if
* name is a string or a more specific type if it a member of
* Blockly.utils.Svg
* @template T
*/
function createSvgElement<T>(name: string|Blockly.utils.Svg<T>, attrs: Object, opt_parent?: Element): T;
/**
* Add a CSS class to a element.
* Similar to Closure's goog.dom.classes.add, except it handles SVG elements.
* @param {!Element} element DOM element to add class to.
* @param {string} className Name of class to add.
* @return {boolean} True if class was added, false if already present.
*/
function addClass(element: Element, className: string): boolean;
/**
* Removes multiple calsses from an element.
* @param {!Element} element DOM element to remove classes from.
* @param {string} classNames A string of one or multiple class names for an
* element.
*/
function removeClasses(element: Element, classNames: string): void;
/**
* Remove a CSS class from a element.
* Similar to Closure's goog.dom.classes.remove, except it handles SVG elements.
* @param {!Element} element DOM element to remove class from.
* @param {string} className Name of class to remove.
* @return {boolean} True if class was removed, false if never present.
*/
function removeClass(element: Element, className: string): boolean;
/**
* Checks if an element has the specified CSS class.
* Similar to Closure's goog.dom.classes.has, except it handles SVG elements.
* @param {!Element} element DOM element to check.
* @param {string} className Name of class to check.
* @return {boolean} True if class exists, false otherwise.
*/
function hasClass(element: Element, className: string): boolean;
/**
* Removes a node from its parent. No-op if not attached to a parent.
* @param {?Node} node The node to remove.
* @return {?Node} The node removed if removed; else, null.
*/
function removeNode(node: Node): Node;
/**
* Insert a node after a reference node.
* Contrast with node.insertBefore function.
* @param {!Element} newNode New element to insert.
* @param {!Element} refNode Existing element to precede new node.
*/
function insertAfter(newNode: Element, refNode: Element): void;
/**
* Whether a node contains another node.
* @param {!Node} parent The node that should contain the other node.
* @param {!Node} descendant The node to test presence of.
* @return {boolean} Whether the parent node contains the descendant node.
*/
function containsNode(parent: Node, descendant: Node): boolean;
/**
* Sets the CSS transform property on an element. This function sets the
* non-vendor-prefixed and vendor-prefixed versions for backwards compatibility
* with older browsers. See https://caniuse.com/#feat=transforms2d
* @param {!Element} element Element to which the CSS transform will be applied.
* @param {string} transform The value of the CSS `transform` property.
*/
function setCssTransform(element: Element, transform: string): void;
/**
* Start caching text widths. Every call to this function MUST also call
* stopTextWidthCache. Caches must not survive between execution threads.
*/
function startTextWidthCache(): void;
/**
* Stop caching field widths. Unless caching was already on when the
* corresponding call to startTextWidthCache was made.
*/
function stopTextWidthCache(): void;
/**
* Gets the width of a text element, caching it in the process.
* @param {!Element} textElement An SVG 'text' element.
* @return {number} Width of element.
*/
function getTextWidth(textElement: Element): number;
/**
* Gets the width of a text element using a faster method than `getTextWidth`.
* This method requires that we know the text element's font family and size in
* advance. Similar to `getTextWidth`, we cache the width we compute.
* @param {!Element} textElement An SVG 'text' element.
* @param {number} fontSize The font size to use.
* @param {string} fontWeight The font weight to use.
* @param {string} fontFamily The font family to use.
* @return {number} Width of element.
*/
function getFastTextWidth(textElement: Element, fontSize: number, fontWeight: string, fontFamily: string): number;
/**
* Gets the width of a text element using a faster method than `getTextWidth`.
* This method requires that we know the text element's font family and size in
* advance. Similar to `getTextWidth`, we cache the width we compute.
* This method is similar to ``getFastTextWidth`` but expects the font size
* parameter to be a string.
* @param {!Element} textElement An SVG 'text' element.
* @param {string} fontSize The font size to use.
* @param {string} fontWeight The font weight to use.
* @param {string} fontFamily The font family to use.
* @return {number} Width of element.
*/
function getFastTextWidthWithSizeString(textElement: Element, fontSize: string, fontWeight: string, fontFamily: string): number;
/**
* Measure a font's metrics. The height and baseline values.
* @param {string} text Text to measure the font dimensions of.
* @param {string} fontSize The font size to use.
* @param {string} fontWeight The font weight to use.
* @param {string} fontFamily The font family to use.
* @return {{height: number, baseline: number}} Font measurements.
*/
function measureFontMetrics(text: string, fontSize: string, fontWeight: string, fontFamily: string): { height: number; baseline: number };
}
declare module Blockly.utils {
/**
* Reference to the global object.
*
* More info on this implementation here:
* https://docs.google.com/document/d/1NAeW4Wk7I7FV0Y2tcUFvQdGMc89k2vdgSXInw8_nvCI/edit
*/
var global: any /*missing*/;
}
declare module Blockly.utils.IdGenerator {
/**
* Gets the next unique ID.
* IDs are compatible with the HTML4 id attribute restrictions:
* Use only ASCII letters, digits, '_', '-' and '.'
* @return {string} The next unique identifier.
*/
function getNextUniqueId(): string;
}
declare module Blockly.utils {
/**
* Key codes for common characters.
*
* Copied from Closure's goog.events.KeyCodes
*
* This list is not localized and therefore some of the key codes are not
* correct for non US keyboard layouts. See comments below.
*
* @enum {number}
*/
enum KeyCodes { WIN_KEY_FF_LINUX, MAC_ENTER, BACKSPACE, TAB, NUM_CENTER, ENTER, SHIFT, CTRL, ALT, PAUSE, CAPS_LOCK, ESC, SPACE, PAGE_UP, PAGE_DOWN, END, HOME, LEFT, UP, RIGHT, DOWN, PLUS_SIGN, PRINT_SCREEN, INSERT, DELETE, ZERO, ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, FF_SEMICOLON, FF_EQUALS, FF_DASH, FF_HASH, QUESTION_MARK, AT_SIGN, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, META, WIN_KEY_RIGHT, CONTEXT_MENU, NUM_ZERO, NUM_ONE, NUM_TWO, NUM_THREE, NUM_FOUR, NUM_FIVE, NUM_SIX, NUM_SEVEN, NUM_EIGHT, NUM_NINE, NUM_MULTIPLY, NUM_PLUS, NUM_MINUS, NUM_PERIOD, NUM_DIVISION, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, NUMLOCK, SCROLL_LOCK, FIRST_MEDIA_KEY, LAST_MEDIA_KEY, SEMICOLON, DASH, EQUALS, COMMA, PERIOD, SLASH, APOSTROPHE, TILDE, SINGLE_QUOTE, OPEN_SQUARE_BRACKET, BACKSLASH, CLOSE_SQUARE_BRACKET, WIN_KEY, MAC_FF_META, MAC_WK_CMD_LEFT, MAC_WK_CMD_RIGHT, WIN_IME, VK_NONAME, PHANTOM }
}
declare module Blockly.utils.math {
/**
* Converts degrees to radians.
* Copied from Closure's goog.math.toRadians.
* @param {number} angleDegrees Angle in degrees.
* @return {number} Angle in radians.
*/
function toRadians(angleDegrees: number): number;
/**
* Converts radians to degrees.
* Copied from Closure's goog.math.toDegrees.
* @param {number} angleRadians Angle in radians.
* @return {number} Angle in degrees.
*/
function toDegrees(angleRadians: number): number;
/**
* Clamp the provided number between the lower bound and the upper bound.
* @param {number} lowerBound The desired lower bound.
* @param {number} number The number to clamp.
* @param {number} upperBound The desired upper bound.
* @return {number} The clamped number.
*/
function clamp(lowerBound: number, number: number, upperBound: number): number;
}
declare module Blockly.utils {
/**
* @record
*/
function Metrics(): void;
}
declare module Blockly.utils.object {
/**
* Inherit the prototype methods from one constructor into another.
*
* @param {!Function} childCtor Child class.
* @param {!Function} parentCtor Parent class.
* @suppress {strictMissingProperties} superClass_ is not defined on Function.
*/
function inherits(childCtor: Function, parentCtor: Function): void;
/**
* Copies all the members of a source object to a target object.
* @param {!Object} target Target.
* @param {!Object} source Source.
*/
function mixin(target: Object, source: Object): void;
/**
* Complete a deep merge of all members of a source object with a target object.
* @param {!Object} target Target.
* @param {!Object} source Source.
* @return {!Object} The resulting object.
*/
function deepMerge(target: Object, source: Object): Object;
/**
* Returns an array of a given object's own enumerable property values.
* @param {!Object} obj Object containing values.
* @return {!Array} Array of values.
*/
function values(obj: Object): any[];
}
declare module Blockly.utils {
class Rect extends Rect__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Rect__Class {
/**
* Class for representing rectangular regions.
* @param {number} top Top.
* @param {number} bottom Bottom.
* @param {number} left Left.
* @param {number} right Right.
* @struct
* @constructor
*/
constructor(top: number, bottom: number, left: number, right: number);
/** @type {number} */
top: number;
/** @type {number} */
bottom: number;
/** @type {number} */
left: number;
/** @type {number} */
right: number;
/**
* Tests whether this rectangle contains a x/y coordinate.
*
* @param {number} x The x coordinate to test for containment.
* @param {number} y The y coordinate to test for containment.
* @return {boolean} Whether this rectangle contains given coordinate.
*/
contains(x: number, y: number): boolean;
/**
* Tests whether this rectangle intersects the provided rectangle.
* Assumes that the coordinate system increases going down and left.
* @param {!Blockly.utils.Rect} other The other rectangle to check for
* intersection with.
* @return {boolean} Whether this rectangle intersects the provided rectangle.
*/
intersects(other: Blockly.utils.Rect): boolean;
}
}
declare module Blockly.utils {
class Size extends Size__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Size__Class {
/**
* Class for representing sizes consisting of a width and height.
* @param {number} width Width.
* @param {number} height Height.
* @struct
* @constructor
*/
constructor(width: number, height: number);
/**
* Width
* @type {number}
*/
width: number;
/**
* Height
* @type {number}
*/
height: number;
}
}
declare module Blockly.utils.Size {
/**
* Compares sizes for equality.
* @param {?Blockly.utils.Size} a A Size.
* @param {?Blockly.utils.Size} b A Size.
* @return {boolean} True iff the sizes have equal widths and equal
* heights, or if both are null.
*/
function equals(a: Blockly.utils.Size, b: Blockly.utils.Size): boolean;
}
declare module Blockly.utils._string {
/**
* Fast prefix-checker.
* Copied from Closure's goog.string.startsWith.
* @param {string} str The string to check.
* @param {string} prefix A string to look for at the start of `str`.
* @return {boolean} True if `str` begins with `prefix`.
*/
function startsWith(str: string, prefix: string): boolean;
/**
* Given an array of strings, return the length of the shortest one.
* @param {!Array<string>} array Array of strings.
* @return {number} Length of shortest string.
*/
function shortestStringLength(array: string[]): number;
/**
* Given an array of strings, return the length of the common prefix.
* Words may not be split. Any space after a word is included in the length.
* @param {!Array<string>} array Array of strings.
* @param {number=} opt_shortest Length of shortest string.
* @return {number} Length of common prefix.
*/
function commonWordPrefix(array: string[], opt_shortest?: number): number;
/**
* Given an array of strings, return the length of the common suffix.
* Words may not be split. Any space after a word is included in the length.
* @param {!Array<string>} array Array of strings.
* @param {number=} opt_shortest Length of shortest string.
* @return {number} Length of common suffix.
*/
function commonWordSuffix(array: string[], opt_shortest?: number): number;
/**
* Wrap text to the specified width.
* @param {string} text Text to wrap.
* @param {number} limit Width to wrap each line.
* @return {string} Wrapped text.
*/
function wrap(text: string, limit: number): string;
}
declare module Blockly.utils.style {
/**
* Gets the height and width of an element.
* Similar to Closure's goog.style.getSize
* @param {!Element} element Element to get size of.
* @return {!Blockly.utils.Size} Object with width/height properties.
*/
function getSize(element: Element): Blockly.utils.Size;
/**
* Retrieves a computed style value of a node. It returns empty string if the
* value cannot be computed (which will be the case in Internet Explorer) or
* "none" if the property requested is an SVG one and it has not been
* explicitly set (firefox and webkit).
*
* Copied from Closure's goog.style.getComputedStyle
*
* @param {!Element} element Element to get style of.
* @param {string} property Property to get (camel-case).
* @return {string} Style value.
*/
function getComputedStyle(element: Element, property: string): string;
/**
* Gets the cascaded style value of a node, or null if the value cannot be
* computed (only Internet Explorer can do this).
*
* Copied from Closure's goog.style.getCascadedStyle
*
* @param {!Element} element Element to get style of.
* @param {string} style Property to get (camel-case).
* @return {string} Style value.
*/
function getCascadedStyle(element: Element, style: string): string;
/**
* Returns a Coordinate object relative to the top-left of the HTML document.
* Similar to Closure's goog.style.getPageOffset
* @param {!Element} el Element to get the page offset for.
* @return {!Blockly.utils.Coordinate} The page offset.
*/
function getPageOffset(el: Element): Blockly.utils.Coordinate;
/**
* Calculates the viewport coordinates relative to the document.
* Similar to Closure's goog.style.getViewportPageOffset
* @return {!Blockly.utils.Coordinate} The page offset of the viewport.
*/
function getViewportPageOffset(): Blockly.utils.Coordinate;
/**
* Shows or hides an element from the page. Hiding the element is done by
* setting the display property to "none", removing the element from the
* rendering hierarchy so it takes up no space. To show the element, the default
* inherited display property is restored (defined either in stylesheets or by
* the browser's default style rules).
* Copied from Closure's goog.style.getViewportPageOffset
*
* @param {!Element} el Element to show or hide.
* @param {*} isShown True to render the element in its default style,
* false to disable rendering the element.
*/
function setElementShown(el: Element, isShown: any): void;
/**
* Returns true if the element is using right to left (RTL) direction.
* Copied from Closure's goog.style.isRightToLeft
*
* @param {!Element} el The element to test.
* @return {boolean} True for right to left, false for left to right.
*/
function isRightToLeft(el: Element): boolean;
/**
* Gets the computed border widths (on all sides) in pixels
* Copied from Closure's goog.style.getBorderBox
* @param {!Element} element The element to get the border widths for.
* @return {!Object} The computed border widths.
*/
function getBorderBox(element: Element): Object;
/**
* Changes the scroll position of `container` with the minimum amount so
* that the content and the borders of the given `element` become visible.
* If the element is bigger than the container, its top left corner will be
* aligned as close to the container's top left corner as possible.
* Copied from Closure's goog.style.scrollIntoContainerView
*
* @param {!Element} element The element to make visible.
* @param {!Element} container The container to scroll. If not set, then the
* document scroll element will be used.
* @param {boolean=} opt_center Whether to center the element in the container.
* Defaults to false.
*/
function scrollIntoContainerView(element: Element, container: Element, opt_center?: boolean): void;
/**
* Calculate the scroll position of `container` with the minimum amount so
* that the content and the borders of the given `element` become visible.
* If the element is bigger than the container, its top left corner will be
* aligned as close to the container's top left corner as possible.
* Copied from Closure's goog.style.getContainerOffsetToScrollInto
*
* @param {!Element} element The element to make visible.
* @param {!Element} container The container to scroll. If not set, then the
* document scroll element will be used.
* @param {boolean=} opt_center Whether to center the element in the container.
* Defaults to false.
* @return {!Blockly.utils.Coordinate} The new scroll position of the container,
* in form of goog.math.Coordinate(scrollLeft, scrollTop).
*/
function getContainerOffsetToScrollInto(element: Element, container: Element, opt_center?: boolean): Blockly.utils.Coordinate;
}
declare module Blockly.utils {
class Svg<T> extends Svg__Class<T> { }
/** Fake class which should be extended to avoid inheriting static properties */
class Svg__Class<T> {
/**
* A name with the type of the SVG element stored in the generic.
* @param {string} tagName The SVG element tag name.
* @constructor
* @template T
* @private
*/
constructor(tagName: string);
}
}
declare module Blockly.utils.Svg {
/** @type {!Blockly.utils.Svg<!SVGAnimateElement>}
* @package
*/
var ANIMATE: Blockly.utils.Svg<SVGAnimateElement>;
/** @type {!Blockly.utils.Svg<!SVGCircleElement>}
* @package
*/
var CIRCLE: Blockly.utils.Svg<SVGCircleElement>;
/** @type {!Blockly.utils.Svg<!SVGClipPathElement>}
* @package
*/
var CLIPPATH: Blockly.utils.Svg<SVGClipPathElement>;
/** @type {!Blockly.utils.Svg<!SVGDefsElement>}
* @package
*/
var DEFS: Blockly.utils.Svg<SVGDefsElement>;
/** @type {!Blockly.utils.Svg<!SVGFECompositeElement>}
* @package
*/
var FECOMPOSITE: Blockly.utils.Svg<SVGFECompositeElement>;
/** @type {!Blockly.utils.Svg<!SVGFEComponentTransferElement>}
* @package
*/
var FECOMPONENTTRANSFER: Blockly.utils.Svg<SVGFEComponentTransferElement>;
/** @type {!Blockly.utils.Svg<!SVGFEFloodElement>}
* @package
*/
var FEFLOOD: Blockly.utils.Svg<SVGFEFloodElement>;
/** @type {!Blockly.utils.Svg<!SVGFEFuncAElement>}
* @package
*/
var FEFUNCA: Blockly.utils.Svg<SVGFEFuncAElement>;
/** @type {!Blockly.utils.Svg<!SVGFEGaussianBlurElement>}
* @package
*/
var FEGAUSSIANBLUR: Blockly.utils.Svg<SVGFEGaussianBlurElement>;
/** @type {!Blockly.utils.Svg<!SVGFEPointLightElement>}
* @package
*/
var FEPOINTLIGHT: Blockly.utils.Svg<SVGFEPointLightElement>;
/** @type {!Blockly.utils.Svg<!SVGFESpecularLightingElement>}
* @package
*/
var FESPECULARLIGHTING: Blockly.utils.Svg<SVGFESpecularLightingElement>;
/** @type {!Blockly.utils.Svg<!SVGFilterElement>}
* @package
*/
var FILTER: Blockly.utils.Svg<SVGFilterElement>;
/** @type {!Blockly.utils.Svg<!SVGForeignObjectElement>}
* @package
*/
var FOREIGNOBJECT: Blockly.utils.Svg<SVGForeignObjectElement>;
/** @type {!Blockly.utils.Svg<!SVGGElement>}
* @package
*/
var G: Blockly.utils.Svg<SVGGElement>;
/** @type {!Blockly.utils.Svg<!SVGImageElement>}
* @package
*/
var IMAGE: Blockly.utils.Svg<SVGImageElement>;
/** @type {!Blockly.utils.Svg<!SVGLineElement>}
* @package
*/
var LINE: Blockly.utils.Svg<SVGLineElement>;
/** @type {!Blockly.utils.Svg<!SVGPathElement>}
* @package
*/
var PATH: Blockly.utils.Svg<SVGPathElement>;
/** @type {!Blockly.utils.Svg<!SVGPatternElement>}
* @package
*/
var PATTERN: Blockly.utils.Svg<SVGPatternElement>;
/** @type {!Blockly.utils.Svg<!SVGPolygonElement>}
* @package
*/
var POLYGON: Blockly.utils.Svg<SVGPolygonElement>;
/** @type {!Blockly.utils.Svg<!SVGRectElement>}
* @package
*/
var RECT: Blockly.utils.Svg<SVGRectElement>;
/** @type {!Blockly.utils.Svg<!SVGSVGElement>}
* @package
*/
var SVG: Blockly.utils.Svg<SVGSVGElement>;
/** @type {!Blockly.utils.Svg<!SVGTextElement>}
* @package
*/
var TEXT: Blockly.utils.Svg<SVGTextElement>;
/** @type {!Blockly.utils.Svg<!SVGTSpanElement>}
* @package
*/
var TSPAN: Blockly.utils.Svg<SVGTSpanElement>;
}
declare module Blockly.utils.svgPaths {
/**
* Create a string representing the given x, y pair. It does not matter whether
* the coordinate is relative or absolute. The result has leading
* and trailing spaces, and separates the x and y coordinates with a comma but
* no space.
* @param {number} x The x coordinate.
* @param {number} y The y coordinate.
* @return {string} A string of the format ' x,y '
* @public
*/
function point(x: number, y: number): string;
/**
* Draw a cubic or quadratic curve. See
* developer.mozilla.org/en-US/docs/Web/SVG/Attribute/d#Cubic_B%C3%A9zier_Curve
* These coordinates are unitless and hence in the user coordinate system.
* @param {string} command The command to use.
* Should be one of: c, C, s, S, q, Q.
* @param {!Array<string>} points An array containing all of the points to pass to the
* curve command, in order. The points are represented as strings of the
* format ' x, y '.
* @return {string} A string defining one or more Bezier curves. See the MDN
* documentation for exact format.
* @public
*/
function curve(command: string, points: string[]): string;
/**
* Move the cursor to the given position without drawing a line.
* The coordinates are absolute.
* These coordinates are unitless and hence in the user coordinate system.
* See developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths#Line_commands
* @param {number} x The absolute x coordinate.
* @param {number} y The absolute y coordinate.
* @return {string} A string of the format ' M x,y '
* @public
*/
function moveTo(x: number, y: number): string;
/**
* Move the cursor to the given position without drawing a line.
* Coordinates are relative.
* These coordinates are unitless and hence in the user coordinate system.
* See developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths#Line_commands
* @param {number} dx The relative x coordinate.
* @param {number} dy The relative y coordinate.
* @return {string} A string of the format ' m dx,dy '
* @public
*/
function moveBy(dx: number, dy: number): string;
/**
* Draw a line from the current point to the end point, which is the current
* point shifted by dx along the x-axis and dy along the y-axis.
* These coordinates are unitless and hence in the user coordinate system.
* See developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths#Line_commands
* @param {number} dx The relative x coordinate.
* @param {number} dy The relative y coordinate.
* @return {string} A string of the format ' l dx,dy '
* @public
*/
function lineTo(dx: number, dy: number): string;
/**
* Draw multiple lines connecting all of the given points in order. This is
* equivalent to a series of 'l' commands.
* These coordinates are unitless and hence in the user coordinate system.
* See developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths#Line_commands
* @param {!Array<string>} points An array containing all of the points to
* draw lines to, in order. The points are represented as strings of the
* format ' dx,dy '.
* @return {string} A string of the format ' l (dx,dy)+ '
* @public
*/
function line(points: string[]): string;
/**
* Draw a horizontal or vertical line.
* The first argument specifies the direction and whether the given position is
* relative or absolute.
* These coordinates are unitless and hence in the user coordinate system.
* See developer.mozilla.org/en-US/docs/Web/SVG/Attribute/d#LineTo_path_commands
* @param {string} command The command to prepend to the coordinate. This
* should be one of: V, v, H, h.
* @param {number} val The coordinate to pass to the command. It may be
* absolute or relative.
* @return {string} A string of the format ' command val '
* @public
*/
function lineOnAxis(command: string, val: number): string;
/**
* Draw an elliptical arc curve.
* These coordinates are unitless and hence in the user coordinate system.
* See developer.mozilla.org/en-US/docs/Web/SVG/Attribute/d#Elliptical_Arc_Curve
* @param {string} command The command string. Either 'a' or 'A'.
* @param {string} flags The flag string. See the MDN documentation for a
* description and examples.
* @param {number} radius The radius of the arc to draw.
* @param {string} point The point to move the cursor to after drawing the arc,
* specified either in absolute or relative coordinates depending on the
* command.
* @return {string} A string of the format 'command radius radius flags point'
* @public
*/
function arc(command: string, flags: string, radius: number, point: string): string;
}
declare module Blockly.utils.toolbox {
/**
* The information needed to create a block in the toolbox.
* @typedef {{
* kind:string,
* blockxml:(string|!Node|undefined),
* type:(string|undefined),
* gap:(string|number|undefined),
* disabled: (string|boolean|undefined)
* }}
*/
interface BlockInfo {
kind: string;
blockxml: string|Node|any /*undefined*/;
type: string|any /*undefined*/;
gap: string|number|any /*undefined*/;
disabled: string|boolean|any /*undefined*/
}
/**
* The information needed to create a separator in the toolbox.
* @typedef {{
* kind:string,
* id:(string|undefined),
* gap:(number|undefined),
* cssconfig:(!Blockly.ToolboxSeparator.CssConfig|undefined)
* }}
*/
interface SeparatorInfo {
kind: string;
id: string|any /*undefined*/;
gap: number|any /*undefined*/;
cssconfig: Blockly.ToolboxSeparator.CssConfig|any /*undefined*/
}
/**
* The information needed to create a button in the toolbox.
* @typedef {{
* kind:string,
* text:string,
* callbackkey:string
* }}
*/
interface ButtonInfo {
kind: string;
text: string;
callbackkey: string
}
/**
* The information needed to create a label in the toolbox.
* @typedef {{
* kind:string,
* text:string,
* id:(string|undefined)
* }}
*/
interface LabelInfo {
kind: string;
text: string;
id: string|any /*undefined*/
}
/**
* The information needed to create either a button or a label in the flyout.
* @typedef {Blockly.utils.toolbox.ButtonInfo|
* Blockly.utils.toolbox.LabelInfo}
*/
type ButtonOrLabelInfo = Blockly.utils.toolbox.ButtonInfo|Blockly.utils.toolbox.LabelInfo;
/**
* The information needed to create a category in the toolbox.
* @typedef {{
* kind:string,
* name:string,
* contents:!Array<!Blockly.utils.toolbox.ToolboxItemInfo>,
* id:(string|undefined),
* categorystyle:(string|undefined),
* colour:(string|undefined),
* cssconfig:(!Blockly.ToolboxCategory.CssConfig|undefined),
* hidden:(string|undefined)
* }}
*/
interface StaticCategoryInfo {
kind: string;
name: string;
contents: Blockly.utils.toolbox.ToolboxItemInfo[];
id: string|any /*undefined*/;
categorystyle: string|any /*undefined*/;
colour: string|any /*undefined*/;
cssconfig: Blockly.ToolboxCategory.CssConfig|any /*undefined*/;
hidden: string|any /*undefined*/
}
/**
* The information needed to create a custom category.
* @typedef {{
* kind:string,
* custom:string,
* id:(string|undefined),
* categorystyle:(string|undefined),
* colour:(string|undefined),
* cssconfig:(!Blockly.ToolboxCategory.CssConfig|undefined),
* hidden:(string|undefined)
* }}
*/
interface DynamicCategoryInfo {
kind: string;
custom: string;
id: string|any /*undefined*/;
categorystyle: string|any /*undefined*/;
colour: string|any /*undefined*/;
cssconfig: Blockly.ToolboxCategory.CssConfig|any /*undefined*/;
hidden: string|any /*undefined*/
}
/**
* The information needed to create either a dynamic or static category.
* @typedef {Blockly.utils.toolbox.StaticCategoryInfo|
* Blockly.utils.toolbox.DynamicCategoryInfo}
*/
type CategoryInfo = Blockly.utils.toolbox.StaticCategoryInfo|Blockly.utils.toolbox.DynamicCategoryInfo;
/**
* Any information that can be used to create an item in the toolbox.
* @typedef {Blockly.utils.toolbox.FlyoutItemInfo|
* Blockly.utils.toolbox.StaticCategoryInfo}
*/
type ToolboxItemInfo = Blockly.utils.toolbox.FlyoutItemInfo|Blockly.utils.toolbox.StaticCategoryInfo;
/**
* All the different types that can be displayed in a flyout.
* @typedef {Blockly.utils.toolbox.BlockInfo|
* Blockly.utils.toolbox.SeparatorInfo|
* Blockly.utils.toolbox.ButtonInfo|
* Blockly.utils.toolbox.LabelInfo|
* Blockly.utils.toolbox.DynamicCategoryInfo}
*/
type FlyoutItemInfo = Blockly.utils.toolbox.BlockInfo|Blockly.utils.toolbox.SeparatorInfo|Blockly.utils.toolbox.ButtonInfo|Blockly.utils.toolbox.LabelInfo|Blockly.utils.toolbox.DynamicCategoryInfo;
/**
* The JSON definition of a toolbox.
* @typedef {{
* kind:(string|undefined),
* contents:!Array<!Blockly.utils.toolbox.ToolboxItemInfo>
* }}
*/
interface ToolboxInfo {
kind: string|any /*undefined*/;
contents: Blockly.utils.toolbox.ToolboxItemInfo[]
}
/**
* An array holding flyout items.
* @typedef {
* Array<!Blockly.utils.toolbox.FlyoutItemInfo>
* }
*/
interface FlyoutItemInfoArray extends Array<Blockly.utils.toolbox.FlyoutItemInfo> { }
/**
* All of the different types that can create a toolbox.
* @typedef {Node|
* Blockly.utils.toolbox.ToolboxInfo|
* string}
*/
type ToolboxDefinition = Node|Blockly.utils.toolbox.ToolboxInfo|string;
/**
* All of the different types that can be used to show items in a flyout.
* @typedef {Blockly.utils.toolbox.FlyoutItemInfoArray|
* NodeList|
* Blockly.utils.toolbox.ToolboxInfo|
* Array<!Node>}
*/
type FlyoutDefinition = Blockly.utils.toolbox.FlyoutItemInfoArray|NodeList|Blockly.utils.toolbox.ToolboxInfo|Node[];
/**
* The name used to identify a toolbox that has category like items.
* This only needs to be used if a toolbox wants to be treated like a category
* toolbox but does not actually contain any toolbox items with the kind
* 'category'.
* @const {string}
*/
var CATEGORY_TOOLBOX_KIND: any /*missing*/;
/**
* The name used to identify a toolbox that has no categories and is displayed
* as a simple flyout displaying blocks, buttons, or labels.
* @const {string}
*/
var FLYOUT_TOOLBOX_KIND: any /*missing*/;
/**
* Position of the the toolbox and/or flyout relative to the workspace.
* @enum {number}
*/
enum Position { TOP, BOTTOM, LEFT, RIGHT }
/**
* Converts the toolbox definition into toolbox JSON.
* @param {?Blockly.utils.toolbox.ToolboxDefinition} toolboxDef The definition
* of the toolbox in one of its many forms.
* @return {?Blockly.utils.toolbox.ToolboxInfo} Object holding information
* for creating a toolbox.
* @package
*/
function convertToolboxDefToJson(toolboxDef: Blockly.utils.toolbox.ToolboxDefinition): Blockly.utils.toolbox.ToolboxInfo;
/**
* Converts the flyout definition into a list of flyout items.
* @param {?Blockly.utils.toolbox.FlyoutDefinition} flyoutDef The definition of
* the flyout in one of its many forms.
* @return {!Blockly.utils.toolbox.FlyoutItemInfoArray} A list of flyout items.
* @package
*/
function convertFlyoutDefToJsonArray(flyoutDef: Blockly.utils.toolbox.FlyoutDefinition): Blockly.utils.toolbox.FlyoutItemInfoArray;
/**
* Whether or not the toolbox definition has categories.
* @param {?Blockly.utils.toolbox.ToolboxInfo} toolboxJson Object holding
* information for creating a toolbox.
* @return {boolean} True if the toolbox has categories.
* @package
*/
function hasCategories(toolboxJson: Blockly.utils.toolbox.ToolboxInfo): boolean;
/**
* Whether or not the category is collapsible.
* @param {!Blockly.utils.toolbox.CategoryInfo} categoryInfo Object holing
* information for creating a category.
* @return {boolean} True if the category has subcategories.
* @package
*/
function isCategoryCollapsible(categoryInfo: Blockly.utils.toolbox.CategoryInfo): boolean;
/**
* Parse the provided toolbox tree into a consistent DOM format.
* @param {?Node|?string} toolboxDef DOM tree of blocks, or text representation
* of same.
* @return {?Node} DOM tree of blocks, or null.
*/
function parseToolboxTree(toolboxDef: Node|string): Node;
}
declare module Blockly.utils.userAgent {
/** @const {boolean} */
var IE: any /*missing*/;
/** @const {boolean} */
var EDGE: any /*missing*/;
/** @const {boolean} */
var JAVA_FX: any /*missing*/;
/** @const {boolean} */
var CHROME: any /*missing*/;
/** @const {boolean} */
var WEBKIT: any /*missing*/;
/** @const {boolean} */
var GECKO: any /*missing*/;
/** @const {boolean} */
var ANDROID: any /*missing*/;
/** @const {boolean} */
var IPAD: any /*missing*/;
/** @const {boolean} */
var IPOD: any /*missing*/;
/** @const {boolean} */
var IPHONE: any /*missing*/;
/** @const {boolean} */
var MAC: any /*missing*/;
/** @const {boolean} */
var TABLET: any /*missing*/;
/** @const {boolean} */
var MOBILE: any /*missing*/;
}
declare module Blockly.utils.xml {
/**
* Namespace for Blockly's XML.
*/
var NAME_SPACE: any /*missing*/;
/**
* Get the document object. This method is overridden in the Node.js build of
* Blockly. See gulpfile.js, package-blockly-node task.
* @return {!Document} The document object.
* @public
*/
function document(): Document;
/**
* Create DOM element for XML.
* @param {string} tagName Name of DOM element.
* @return {!Element} New DOM element.
* @public
*/
function createElement(tagName: string): Element;
/**
* Create text element for XML.
* @param {string} text Text content.
* @return {!Text} New DOM text node.
* @public
*/
function createTextNode(text: string): Text;
/**
* Converts an XML string into a DOM tree.
* @param {string} text XML string.
* @return {Document} The DOM document.
* @throws if XML doesn't parse.
* @public
*/
function textToDomDocument(text: string): Document;
/**
* Converts a DOM structure into plain text.
* Currently the text format is fairly ugly: all one line with no whitespace.
* @param {!Node} dom A tree of XML nodes.
* @return {string} Text representation.
* @public
*/
function domToText(dom: Node): string;
}
declare module Blockly.blockRendering {
/**
* Whether or not the debugger is turned on.
* @type {boolean}
* @package
*/
var useDebugger: boolean;
/**
* Registers a new renderer.
* @param {string} name The name of the renderer.
* @param {!Function} rendererClass The new renderer class
* to register.
* @throws {Error} if a renderer with the same name has already been registered.
*/
function register(name: string, rendererClass: Function): void;
/**
* Unregisters the renderer registered with the given name.
* @param {string} name The name of the renderer.
*/
function unregister(name: string): void;
/**
* Turn on the blocks debugger.
* @package
*/
function startDebugger(): void;
/**
* Turn off the blocks debugger.
* @package
*/
function stopDebugger(): void;
/**
* Initialize anything needed for rendering (constants, etc).
* @param {!string} name Name of the renderer to initialize.
* @param {!Blockly.Theme} theme The workspace theme object.
* @param {Object=} opt_rendererOverrides Rendering constant overrides.
* @return {!Blockly.blockRendering.Renderer} The new instance of a renderer.
* Already initialized.
* @package
*/
function init(name: string, theme: Blockly.Theme, opt_rendererOverrides?: Object): Blockly.blockRendering.Renderer;
}
declare module Blockly.blockRendering {
class ConstantProvider extends ConstantProvider__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class ConstantProvider__Class {
/**
* An object that provides constants for rendering blocks.
* @constructor
* @package
*/
constructor();
/**
* The size of an empty spacer.
* @type {number}
*/
NO_PADDING: number;
/**
* The size of small padding.
* @type {number}
*/
SMALL_PADDING: number;
/**
* The size of medium padding.
* @type {number}
*/
MEDIUM_PADDING: number;
/**
* The size of medium-large padding.
* @type {number}
*/
MEDIUM_LARGE_PADDING: number;
/**
* The size of large padding.
* @type {number}
*/
LARGE_PADDING: number;
/**
* Offset from the top of the row for placing fields on inline input rows
* and statement input rows.
* Matches existing rendering (in 2019).
* @type {number}
*/
TALL_INPUT_FIELD_OFFSET_Y: number;
/**
* The height of the puzzle tab used for input and output connections.
* @type {number}
*/
TAB_HEIGHT: number;
/**
* The offset from the top of the block at which a puzzle tab is positioned.
* @type {number}
*/
TAB_OFFSET_FROM_TOP: number;
/**
* Vertical overlap of the puzzle tab, used to make it look more like a puzzle
* piece.
* @type {number}
*/
TAB_VERTICAL_OVERLAP: number;
/**
* The width of the puzzle tab used for input and output connections.
* @type {number}
*/
TAB_WIDTH: number;
/**
* The width of the notch used for previous and next connections.
* @type {number}
*/
NOTCH_WIDTH: number;
/**
* The height of the notch used for previous and next connections.
* @type {number}
*/
NOTCH_HEIGHT: number;
/**
* The minimum width of the block.
* @type {number}
*/
MIN_BLOCK_WIDTH: number;
/**
* The minimum height of a dummy input row.
* @type {number}
*/
DUMMY_INPUT_MIN_HEIGHT: number;
/**
* The minimum height of a dummy input row in a shadow block.
* @type {number}
*/
DUMMY_INPUT_SHADOW_MIN_HEIGHT: number;
/**
* Rounded corner radius.
* @type {number}
*/
CORNER_RADIUS: number;
/**
* Offset from the left side of a block or the inside of a statement input to
* the left side of the notch.
* @type {number}
*/
NOTCH_OFFSET_LEFT: number;
/**
* Additional offset added to the statement input's width to account for the
* notch.
* @type {number}
*/
STATEMENT_INPUT_NOTCH_OFFSET: number;
/**
* Vertical padding between consecutive statement inputs.
* @type {number}
*/
BETWEEN_STATEMENT_PADDING_Y: number;
/**
* The top row's minimum height.
* @type {number}
*/
TOP_ROW_MIN_HEIGHT: number;
/**
* The top row's minimum height if it precedes a statement.
* @type {number}
*/
TOP_ROW_PRECEDES_STATEMENT_MIN_HEIGHT: number;
/**
* The bottom row's minimum height.
* @type {number}
*/
BOTTOM_ROW_MIN_HEIGHT: number;
/**
* The bottom row's minimum height if it follows a statement input.
* @type {number}
*/
BOTTOM_ROW_AFTER_STATEMENT_MIN_HEIGHT: number;
/**
* Whether to add a 'hat' on top of all blocks with no previous or output
* connections. Can be overridden by 'hat' property on Theme.BlockStyle.
* @type {boolean}
*/
ADD_START_HATS: boolean;
/**
* Height of the top hat.
* @type {number}
*/
START_HAT_HEIGHT: number;
/**
* Width of the top hat.
* @type {number}
*/
START_HAT_WIDTH: number;
/**
* The height of an empty inline input.
* @type {number}
*/
EMPTY_INLINE_INPUT_HEIGHT: number;
/**
* The height of an empty statement input. Note that in the old rendering this
* varies slightly depending on whether the block has external or inline inputs.
* In the new rendering this is consistent. It seems unlikely that the old
* behaviour was intentional.
* @type {number}
*/
EMPTY_STATEMENT_INPUT_HEIGHT: number;
/**
* Height of SVG path for jagged teeth at the end of collapsed blocks.
* @type {number}
*/
JAGGED_TEETH_HEIGHT: number;
/**
* Width of SVG path for jagged teeth at the end of collapsed blocks.
* @type {number}
*/
JAGGED_TEETH_WIDTH: number;
/**
* Point size of text.
* @type {number}
*/
FIELD_TEXT_FONTSIZE: number;
/**
* Text font weight.
* @type {string}
*/
FIELD_TEXT_FONTWEIGHT: string;
/**
* Text font family.
* @type {string}
*/
FIELD_TEXT_FONTFAMILY: string;
/**
* Height of text. This constant is dynamically set in ``setFontConstants_``
* to be the height of the text based on the font used.
* @type {number}
*/
FIELD_TEXT_HEIGHT: number;
/**
* Text baseline. This constant is dynamically set in ``setFontConstants_``
* to be the baseline of the text based on the font used.
* @type {number}
*/
FIELD_TEXT_BASELINE: number;
/**
* A field's border rect corner radius.
* @type {number}
*/
FIELD_BORDER_RECT_RADIUS: number;
/**
* A field's border rect default height.
* @type {number}
*/
FIELD_BORDER_RECT_HEIGHT: number;
/**
* A field's border rect X padding.
* @type {number}
*/
FIELD_BORDER_RECT_X_PADDING: number;
/**
* A field's border rect Y padding.
* @type {number}
*/
FIELD_BORDER_RECT_Y_PADDING: number;
/**
* The backing colour of a field's border rect.
* @type {string}
* @package
*/
FIELD_BORDER_RECT_COLOUR: string;
/**
* A field's text element's dominant baseline.
* @type {boolean}
*/
FIELD_TEXT_BASELINE_CENTER: boolean;
/**
* A dropdown field's border rect height.
* @type {number}
*/
FIELD_DROPDOWN_BORDER_RECT_HEIGHT: number;
/**
* Whether or not a dropdown field should add a border rect when in a shadow
* block.
* @type {boolean}
*/
FIELD_DROPDOWN_NO_BORDER_RECT_SHADOW: boolean;
/**
* Whether or not a dropdown field's div should be coloured to match the
* block colours.
* @type {boolean}
*/
FIELD_DROPDOWN_COLOURED_DIV: boolean;
/**
* Whether or not a dropdown field uses a text or SVG arrow.
* @type {boolean}
*/
FIELD_DROPDOWN_SVG_ARROW: boolean;
/**
* A dropdown field's SVG arrow padding.
* @type {number}
*/
FIELD_DROPDOWN_SVG_ARROW_PADDING: number;
/**
* A dropdown field's SVG arrow size.
* @type {number}
*/
FIELD_DROPDOWN_SVG_ARROW_SIZE: number;
/**
* A dropdown field's SVG arrow datauri.
* @type {string}
*/
FIELD_DROPDOWN_SVG_ARROW_DATAURI: string;
/**
* Whether or not to show a box shadow around the widget div. This is only a
* feature of full block fields.
* @type {boolean}
*/
FIELD_TEXTINPUT_BOX_SHADOW: boolean;
/**
* Whether or not the colour field should display its colour value on the
* entire block.
* @type {boolean}
*/
FIELD_COLOUR_FULL_BLOCK: boolean;
/**
* A colour field's default width.
* @type {number}
*/
FIELD_COLOUR_DEFAULT_WIDTH: number;
/**
* A colour field's default height.
* @type {number}
*/
FIELD_COLOUR_DEFAULT_HEIGHT: number;
/**
* A checkbox field's X offset.
* @type {number}
*/
FIELD_CHECKBOX_X_OFFSET: number;
/**
* A random identifier used to ensure a unique ID is used for each
* filter/pattern for the case of multiple Blockly instances on a page.
* @type {string}
* @package
*/
randomIdentifier: string;
/**
* The ID of the emboss filter, or the empty string if no filter is set.
* @type {string}
* @package
*/
embossFilterId: string;
/**
* The ID of the disabled pattern, or the empty string if no pattern is set.
* @type {string}
* @package
*/
disabledPatternId: string;
/**
* The ID of the debug filter, or the empty string if no pattern is set.
* @type {string}
* @package
*/
debugFilterId: string;
/**
* Cursor colour.
* @type {string}
* @package
*/
CURSOR_COLOUR: string;
/**
* Immovable marker colour.
* @type {string}
* @package
*/
MARKER_COLOUR: string;
/**
* Width of the horizontal cursor.
* @type {number}
* @package
*/
CURSOR_WS_WIDTH: number;
/**
* Height of the horizontal cursor.
* @type {number}
* @package
*/
WS_CURSOR_HEIGHT: number;
/**
* Padding around a stack.
* @type {number}
* @package
*/
CURSOR_STACK_PADDING: number;
/**
* Padding around a block.
* @type {number}
* @package
*/
CURSOR_BLOCK_PADDING: number;
/**
* Stroke of the cursor.
* @type {number}
* @package
*/
CURSOR_STROKE_WIDTH: number;
/**
* Whether text input and colour fields fill up the entire source block.
* @type {boolean}
* @package
*/
FULL_BLOCK_FIELDS: boolean;
/**
* The main colour of insertion markers, in hex. The block is rendered a
* transparent grey by changing the fill opacity in CSS.
* @type {string}
* @package
*/
INSERTION_MARKER_COLOUR: string;
/**
* The insertion marker opacity.
* @type {number}
* @package
*/
INSERTION_MARKER_OPACITY: number;
/**
* Enum for connection shapes.
* @enum {number}
*/
SHAPES: any /*missing*/;
/**
* Initialize shape objects based on the constants set in the constructor.
* @package
*/
init(): void;
/**
* An object containing sizing and path information about collapsed block
* indicators.
* @type {!Object}
*/
JAGGED_TEETH: Object;
/**
* An object containing sizing and path information about notches.
* @type {!Object}
*/
NOTCH: Object;
/**
* An object containing sizing and path information about start hats
* @type {!Object}
*/
START_HAT: Object;
/**
* An object containing sizing and path information about puzzle tabs.
* @type {!Object}
*/
PUZZLE_TAB: Object;
/**
* An object containing sizing and path information about inside corners
* @type {!Object}
*/
INSIDE_CORNERS: Object;
/**
* An object containing sizing and path information about outside corners.
* @type {!Object}
*/
OUTSIDE_CORNERS: Object;
/**
* Refresh constants properties that depend on the theme.
* @param {!Blockly.Theme} theme The current workspace theme.
* @package
*/
setTheme(theme: Blockly.Theme): void;
/**
* The block styles map.
* @type {Object<string, !Blockly.Theme.BlockStyle>}
* @package
*/
blockStyles: { [key: string]: Blockly.Theme.BlockStyle };
/**
* Sets dynamic properties that depend on other values or theme properties.
* @param {!Blockly.Theme} theme The current workspace theme.
* @protected
*/
setDynamicProperties_(theme: Blockly.Theme): void;
/**
* Set constants related to fonts.
* @param {!Blockly.Theme} theme The current workspace theme.
* @protected
*/
setFontConstants_(theme: Blockly.Theme): void;
/**
* Set constants from a theme's component styles.
* @param {!Blockly.Theme} theme The current workspace theme.
* @protected
*/
setComponentConstants_(theme: Blockly.Theme): void;
/**
* Get or create a block style based on a single colour value. Generate a name
* for the style based on the colour.
* @param {string} colour #RRGGBB colour string.
* @return {{style: !Blockly.Theme.BlockStyle, name: string}} An object
* containing the style and an autogenerated name for that style.
* @package
*/
getBlockStyleForColour(colour: string): { style: Blockly.Theme.BlockStyle; name: string };
/**
* Gets the BlockStyle for the given block style name.
* @param {?string} blockStyleName The name of the block style.
* @return {!Blockly.Theme.BlockStyle} The named block style, or a default style
* if no style with the given name was found.
*/
getBlockStyle(blockStyleName: string): Blockly.Theme.BlockStyle;
/**
* Create a block style object based on the given colour.
* @param {string} colour #RRGGBB colour string.
* @return {!Blockly.Theme.BlockStyle} A populated block style based on the
* given colour.
* @protected
*/
createBlockStyle_(colour: string): Blockly.Theme.BlockStyle;
/**
* Get a full block style object based on the input style object. Populate
* any missing values.
* @param {{
* colourPrimary:string,
* colourSecondary:(string|undefined),
* colourTertiary:(string|undefined),
* hat:(string|undefined)
* }} blockStyle A full or partial block style object.
* @return {!Blockly.Theme.BlockStyle} A full block style object, with all
* required properties populated.
* @protected
*/
validatedBlockStyle_(blockStyle: { colourPrimary: string; colourSecondary: string|any /*undefined*/; colourTertiary: string|any /*undefined*/; hat: string|any /*undefined*/ }): Blockly.Theme.BlockStyle;
/**
* Generate a secondary colour from the passed in primary colour.
* @param {string} colour Primary colour.
* @return {string} The generated secondary colour.
* @protected
*/
generateSecondaryColour_(colour: string): string;
/**
* Generate a tertiary colour from the passed in primary colour.
* @param {string} colour Primary colour.
* @return {string} The generated tertiary colour.
* @protected
*/
generateTertiaryColour_(colour: string): string;
/**
* Dispose of this constants provider.
* Delete all DOM elements that this provider created.
* @package
*/
dispose(): void;
/**
* @return {!Object} An object containing sizing and path information about
* collapsed block indicators.
* @package
*/
makeJaggedTeeth(): Object;
/**
* @return {!Object} An object containing sizing and path information about
* start hats.
* @package
*/
makeStartHat(): Object;
/**
* @return {!Object} An object containing sizing and path information about
* puzzle tabs.
* @package
*/
makePuzzleTab(): Object;
/**
* @return {!Object} An object containing sizing and path information about
* notches.
* @package
*/
makeNotch(): Object;
/**
* @return {!Object} An object containing sizing and path information about
* inside corners.
* @package
*/
makeInsideCorners(): Object;
/**
* @return {!Object} An object containing sizing and path information about
* outside corners.
* @package
*/
makeOutsideCorners(): Object;
/**
* Get an object with connection shape and sizing information based on the type
* of the connection.
* @param {!Blockly.RenderedConnection} connection The connection to find a
* shape object for
* @return {!Object} The shape object for the connection.
* @package
*/
shapeFor(connection: Blockly.RenderedConnection): Object;
/**
* Create any DOM elements that this renderer needs (filters, patterns, etc).
* @param {!SVGElement} svg The root of the workspace's SVG.
* @param {string} tagName The name to use for the CSS style tag.
* @param {string} selector The CSS selector to use.
* @suppress {strictModuleDepCheck} Debug renderer only included in playground.
* @package
*/
createDom(svg: SVGElement, tagName: string, selector: string): void;
/**
* Inject renderer specific CSS into the page.
* @param {string} tagName The name of the style tag to use.
* @param {string} selector The CSS selector to use.
* @protected
*/
injectCSS_(tagName: string, selector: string): void;
/**
* Get any renderer specific CSS to inject when the renderer is initialized.
* @param {string} selector CSS selector to use.
* @return {!Array<string>} Array of CSS strings.
* @protected
*/
getCSS_(selector: string): string[];
}
}
declare module Blockly.blockRendering {
class Debug extends Debug__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Debug__Class {
/**
* An object that renders rectangles and dots for debugging rendering code.
* @param {!Blockly.blockRendering.ConstantProvider} constants The renderer's
* constants.
* @package
* @constructor
*/
constructor(constants: Blockly.blockRendering.ConstantProvider);
/**
* Remove all elements the this object created on the last pass.
* @package
*/
clearElems(): void;
/**
* Draw a debug rectangle for a spacer (empty) row.
* @param {!Blockly.blockRendering.Row} row The row to render.
* @param {number} cursorY The y position of the top of the row.
* @param {boolean} isRtl Whether the block is rendered RTL.
* @package
*/
drawSpacerRow(row: Blockly.blockRendering.Row, cursorY: number, isRtl: boolean): void;
/**
* Draw a debug rectangle for a horizontal spacer.
* @param {!Blockly.blockRendering.InRowSpacer} elem The spacer to render.
* @param {number} rowHeight The height of the container row.
* @param {boolean} isRtl Whether the block is rendered RTL.
* @package
*/
drawSpacerElem(elem: Blockly.blockRendering.InRowSpacer, rowHeight: number, isRtl: boolean): void;
/**
* Draw a debug rectangle for an in-row element.
* @param {!Blockly.blockRendering.Measurable} elem The element to render.
* @param {boolean} isRtl Whether the block is rendered RTL.
* @package
*/
drawRenderedElem(elem: Blockly.blockRendering.Measurable, isRtl: boolean): void;
/**
* Draw a circle at the location of the given connection. Inputs and outputs
* share the same colours, as do previous and next. When positioned correctly
* a connected pair will look like a bullseye.
* @param {Blockly.RenderedConnection} conn The connection to circle.
* @suppress {visibility} Suppress visibility of conn.offsetInBlock_ since this
* is a debug module.
* @package
*/
drawConnection(conn: Blockly.RenderedConnection): void;
/**
* Draw a debug rectangle for a non-empty row.
* @param {!Blockly.blockRendering.Row} row The non-empty row to render.
* @param {number} cursorY The y position of the top of the row.
* @param {boolean} isRtl Whether the block is rendered RTL.
* @package
*/
drawRenderedRow(row: Blockly.blockRendering.Row, cursorY: number, isRtl: boolean): void;
/**
* Draw debug rectangles for a non-empty row and all of its subcomponents.
* @param {!Blockly.blockRendering.Row} row The non-empty row to render.
* @param {number} cursorY The y position of the top of the row.
* @param {boolean} isRtl Whether the block is rendered RTL.
* @package
*/
drawRowWithElements(row: Blockly.blockRendering.Row, cursorY: number, isRtl: boolean): void;
/**
* Draw a debug rectangle around the entire block.
* @param {!Blockly.blockRendering.RenderInfo} info Rendering information about
* the block to debug.
* @package
*/
drawBoundingBox(info: Blockly.blockRendering.RenderInfo): void;
/**
* Do all of the work to draw debug information for the whole block.
* @param {!Blockly.BlockSvg} block The block to draw debug information for.
* @param {!Blockly.blockRendering.RenderInfo} info Rendering information about
* the block to debug.
* @package
*/
drawDebug(block: Blockly.BlockSvg, info: Blockly.blockRendering.RenderInfo): void;
/**
* Show a debug filter to highlight that a block has been rendered.
* @param {!SVGElement} svgPath The block's SVG path.
* @package
*/
drawRender(svgPath: SVGElement): void;
}
}
declare module Blockly.blockRendering.Debug {
/**
* Configuration object containing booleans to enable and disable debug
* rendering of specific rendering components.
* @type {!Object<string, boolean>}
*/
var config: { [key: string]: boolean };
}
declare module Blockly.blockRendering {
class Drawer extends Drawer__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Drawer__Class {
/**
* An object that draws a block based on the given rendering information.
* @param {!Blockly.BlockSvg} block The block to render.
* @param {!Blockly.blockRendering.RenderInfo} info An object containing all
* information needed to render this block.
* @package
* @constructor
*/
constructor(block: Blockly.BlockSvg, info: Blockly.blockRendering.RenderInfo);
/**
* The renderer's constant provider.
* @type {!Blockly.blockRendering.ConstantProvider}
* @protected
*/
constants_: Blockly.blockRendering.ConstantProvider;
/**
* Draw the block to the workspace. Here "drawing" means setting SVG path
* elements and moving fields, icons, and connections on the screen.
*
* The pieces of the paths are pushed into arrays of "steps", which are then
* joined with spaces and set directly on the block. This guarantees that
* the steps are separated by spaces for improved readability, but isn't
* required.
* @package
*/
draw(): void;
/**
* Save sizing information back to the block
* Most of the rendering information can be thrown away at the end of the
* render. Anything that needs to be kept around should be set in this function.
* @protected
*/
recordSizeOnBlock_(): void;
/**
* Hide icons that were marked as hidden.
* @protected
*/
hideHiddenIcons_(): void;
/**
* Create the outline of the block. This is a single continuous path.
* @protected
*/
drawOutline_(): void;
/**
* Add steps for the top corner of the block, taking into account
* details such as hats and rounded corners.
* @protected
*/
drawTop_(): void;
/**
* Add steps for the jagged edge of a row on a collapsed block.
* @param {!Blockly.blockRendering.Row} row The row to draw the side of.
* @protected
*/
drawJaggedEdge_(row: Blockly.blockRendering.Row): void;
/**
* Add steps for an external value input, rendered as a notch in the side
* of the block.
* @param {!Blockly.blockRendering.Row} row The row that this input
* belongs to.
* @protected
*/
drawValueInput_(row: Blockly.blockRendering.Row): void;
/**
* Add steps for a statement input.
* @param {!Blockly.blockRendering.Row} row The row that this input
* belongs to.
* @protected
*/
drawStatementInput_(row: Blockly.blockRendering.Row): void;
/**
* Add steps for the right side of a row that does not have value or
* statement input connections.
* @param {!Blockly.blockRendering.Row} row The row to draw the
* side of.
* @protected
*/
drawRightSideRow_(row: Blockly.blockRendering.Row): void;
/**
* Add steps for the bottom edge of a block, possibly including a notch
* for the next connection.
* @protected
*/
drawBottom_(): void;
/**
* Add steps for the left side of the block, which may include an output
* connection
* @protected
*/
drawLeft_(): void;
/**
* Draw the internals of the block: inline inputs, fields, and icons. These do
* not depend on the outer path for placement.
* @protected
*/
drawInternals_(): void;
/**
* Push a field or icon's new position to its SVG root.
* @param {!Blockly.blockRendering.Icon|!Blockly.blockRendering.Field} fieldInfo
* The rendering information for the field or icon.
* @protected
*/
layoutField_(fieldInfo: Blockly.blockRendering.Icon|Blockly.blockRendering.Field): void;
/**
* Add steps for an inline input.
* @param {!Blockly.blockRendering.InlineInput} input The information about the
* input to render.
* @protected
*/
drawInlineInput_(input: Blockly.blockRendering.InlineInput): void;
/**
* Position the connection on an inline value input, taking into account
* RTL and the small gap between the parent block and child block which lets the
* parent block's dark path show through.
* @param {Blockly.blockRendering.InlineInput} input The information about
* the input that the connection is on.
* @protected
*/
positionInlineInputConnection_(input: Blockly.blockRendering.InlineInput): void;
/**
* Position the connection on a statement input, taking into account
* RTL and the small gap between the parent block and child block which lets the
* parent block's dark path show through.
* @param {!Blockly.blockRendering.Row} row The row that the connection is on.
* @protected
*/
positionStatementInputConnection_(row: Blockly.blockRendering.Row): void;
/**
* Position the connection on an external value input, taking into account
* RTL and the small gap between the parent block and child block which lets the
* parent block's dark path show through.
* @param {!Blockly.blockRendering.Row} row The row that the connection is on.
* @protected
*/
positionExternalValueConnection_(row: Blockly.blockRendering.Row): void;
/**
* Position the previous connection on a block.
* @protected
*/
positionPreviousConnection_(): void;
/**
* Position the next connection on a block.
* @protected
*/
positionNextConnection_(): void;
/**
* Position the output connection on a block.
* @protected
*/
positionOutputConnection_(): void;
}
}
declare module Blockly.blockRendering {
interface IPathObject {
/**
* The primary path of the block.
* @type {!SVGElement}
*/
svgPath: SVGElement;
/**
* The renderer's constant provider.
* @type {!Blockly.blockRendering.ConstantProvider}
*/
constants: Blockly.blockRendering.ConstantProvider;
/**
* The primary path of the block.
* @type {!Blockly.Theme.BlockStyle}
*/
style: Blockly.Theme.BlockStyle;
/**
* Holds the cursors SVG element when the cursor is attached to the block.
* This is null if there is no cursor on the block.
* @type {SVGElement}
*/
cursorSvg: SVGElement;
/**
* Holds the markers SVG element when the marker is attached to the block.
* This is null if there is no marker on the block.
* @type {SVGElement}
*/
markerSvg: SVGElement;
/**
* Set the path generated by the renderer onto the respective SVG element.
* @param {string} pathString The path.
* @package
*/
setPath(pathString: string): void;
/**
* Apply the stored colours to the block's path, taking into account whether
* the paths belong to a shadow block.
* @param {!Blockly.Block} block The source block.
* @package
*/
applyColour(block: Blockly.Block): void;
/**
* Update the style.
* @param {!Blockly.Theme.BlockStyle} blockStyle The block style to use.
* @package
*/
setStyle(blockStyle: Blockly.Theme.BlockStyle): void;
/**
* Flip the SVG paths in RTL.
* @package
*/
flipRTL: any /*missing*/;
/**
* Add the cursor SVG to this block's SVG group.
* @param {SVGElement} cursorSvg The SVG root of the cursor to be added to the
* block SVG group.
* @package
*/
setCursorSvg(cursorSvg: SVGElement): void;
/**
* Add the marker SVG to this block's SVG group.
* @param {SVGElement} markerSvg The SVG root of the marker to be added to the
* block SVG group.
* @package
*/
setMarkerSvg(markerSvg: SVGElement): void;
/**
* Set whether the block shows a highlight or not. Block highlighting is
* often used to visually mark blocks currently being executed.
* @param {boolean} highlighted True if highlighted.
* @package
*/
updateHighlighted(highlighted: boolean): void;
/**
* Add or remove styling showing that a block is selected.
* @param {boolean} enable True if selection is enabled, false otherwise.
* @package
*/
updateSelected(enable: boolean): void;
/**
* Add or remove styling showing that a block is dragged over a delete area.
* @param {boolean} enable True if the block is being dragged over a delete
* area, false otherwise.
* @package
*/
updateDraggingDelete(enable: boolean): void;
/**
* Add or remove styling showing that a block is an insertion marker.
* @param {boolean} enable True if the block is an insertion marker, false
* otherwise.
* @package
*/
updateInsertionMarker(enable: boolean): void;
/**
* Add or remove styling showing that a block is movable.
* @param {boolean} enable True if the block is movable, false otherwise.
* @package
*/
updateMovable(enable: boolean): void;
/**
* Add or remove styling that shows that if the dragging block is dropped, this
* block will be replaced. If a shadow block, it will disappear. Otherwise it
* will bump.
* @param {boolean} enable True if styling should be added.
* @package
*/
updateReplacementFade(enable: boolean): void;
}
}
declare module Blockly.blockRendering {
class RenderInfo extends RenderInfo__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class RenderInfo__Class {
/**
* An object containing all sizing information needed to draw this block.
*
* This measure pass does not propagate changes to the block (although fields
* may choose to rerender when getSize() is called). However, calling it
* repeatedly may be expensive.
*
* @param {!Blockly.blockRendering.Renderer} renderer The renderer in use.
* @param {!Blockly.BlockSvg} block The block to measure.
* @constructor
* @package
*/
constructor(renderer: Blockly.blockRendering.Renderer, block: Blockly.BlockSvg);
/**
* The block renderer in use.
* @type {!Blockly.blockRendering.Renderer}
* @protected
*/
renderer_: Blockly.blockRendering.Renderer;
/**
* The renderer's constant provider.
* @type {!Blockly.blockRendering.ConstantProvider}
* @protected
*/
constants_: Blockly.blockRendering.ConstantProvider;
/**
* A measurable representing the output connection if the block has one.
* Otherwise null.
* @type {Blockly.blockRendering.OutputConnection}
*/
outputConnection: Blockly.blockRendering.OutputConnection;
/**
* Whether the block should be rendered as a single line, either because it's
* inline or because it has been collapsed.
* @type {boolean}
*/
isInline: boolean;
/**
* Whether the block is collapsed.
* @type {boolean}
*/
isCollapsed: boolean;
/**
* Whether the block is an insertion marker. Insertion markers are the same
* shape as normal blocks, but don't show fields.
* @type {boolean}
*/
isInsertionMarker: boolean;
/**
* True if the block should be rendered right-to-left.
* @type {boolean}
*/
RTL: boolean;
/**
* The height of the rendered block, including child blocks.
* @type {number}
*/
height: number;
/**
* The width of the rendered block, including child blocks.
* @type {number}
*/
widthWithChildren: number;
/**
* The width of the rendered block, excluding child blocks. This is the right
* edge of the block when rendered LTR.
* @type {number}
*/
width: number;
/**
*
* @type {number}
*/
statementEdge: number;
/**
* An array of Row objects containing sizing information.
* @type {!Array<!Blockly.blockRendering.Row>}
*/
rows: Blockly.blockRendering.Row[];
/**
* An array of input rows on the block.
* @type {!Array<!Blockly.blockRendering.InputRow>}
*/
inputRows: Blockly.blockRendering.InputRow[];
/**
* An array of measurable objects containing hidden icons.
* @type {!Array<!Blockly.blockRendering.Icon>}
*/
hiddenIcons: Blockly.blockRendering.Icon[];
/**
* An object with rendering information about the top row of the block.
* @type {!Blockly.blockRendering.TopRow}
*/
topRow: Blockly.blockRendering.TopRow;
/**
* An object with rendering information about the bottom row of the block.
* @type {!Blockly.blockRendering.BottomRow}
*/
bottomRow: Blockly.blockRendering.BottomRow;
/**
* Get the block renderer in use.
* @return {!Blockly.blockRendering.Renderer} The block renderer in use.
* @package
*/
getRenderer(): Blockly.blockRendering.Renderer;
/**
* Populate and return an object containing all sizing information needed to
* draw this block.
*
* This measure pass does not propagate changes to the block (although fields
* may choose to rerender when getSize() is called). However, calling it
* repeatedly may be expensive.
*
* @package
*/
measure(): void;
/**
* Create rows of Measurable objects representing all renderable parts of the
* block.
* @protected
*/
createRows_(): void;
/**
* Create all non-spacer elements that belong on the top row.
* @package
*/
populateTopRow_(): void;
/**
* Create all non-spacer elements that belong on the bottom row.
* @package
*/
populateBottomRow_(): void;
/**
* Add an input element to the active row, if needed, and record the type of the
* input on the row.
* @param {!Blockly.Input} input The input to record information about.
* @param {!Blockly.blockRendering.Row} activeRow The row that is currently being
* populated.
* @protected
*/
addInput_(input: Blockly.Input, activeRow: Blockly.blockRendering.Row): void;
/**
* Decide whether to start a new row between the two Blockly.Inputs.
* @param {!Blockly.Input} input The first input to consider
* @param {Blockly.Input} lastInput The input that follows.
* @return {boolean} True if the next input should be rendered on a new row.
* @protected
*/
shouldStartNewRow_(input: Blockly.Input, lastInput: Blockly.Input): boolean;
/**
* Add horizontal spacing between and around elements within each row.
* @protected
*/
addElemSpacing_(): void;
/**
* Calculate the width of a spacer element in a row based on the previous and
* next elements in that row. For instance, extra padding is added between two
* editable fields.
* @param {Blockly.blockRendering.Measurable} prev The element before the
* spacer.
* @param {Blockly.blockRendering.Measurable} next The element after the spacer.
* @return {number} The size of the spacing between the two elements.
* @protected
*/
getInRowSpacing_(prev: Blockly.blockRendering.Measurable, next: Blockly.blockRendering.Measurable): number;
/**
* Figure out where the right edge of the block and right edge of statement inputs
* should be placed.
* @protected
*/
computeBounds_(): void;
/**
* Extra spacing may be necessary to make sure that the right sides of all
* rows line up. This can only be calculated after a first pass to calculate
* the sizes of all rows.
* @protected
*/
alignRowElements_(): void;
/**
* Calculate the desired width of an input row.
* @param {!Blockly.blockRendering.Row} _row The input row.
* @return {number} The desired width of the input row.
* @protected
*/
getDesiredRowWidth_(_row: Blockly.blockRendering.Row): number;
/**
* Modify the given row to add the given amount of padding around its fields.
* The exact location of the padding is based on the alignment property of the
* last input in the field.
* @param {Blockly.blockRendering.Row} row The row to add padding to.
* @param {number} missingSpace How much padding to add.
* @protected
*/
addAlignmentPadding_(row: Blockly.blockRendering.Row, missingSpace: number): void;
/**
* Align the elements of a statement row based on computed bounds.
* Unlike other types of rows, statement rows add space in multiple places.
* @param {!Blockly.blockRendering.InputRow} row The statement row to resize.
* @protected
*/
alignStatementRow_(row: Blockly.blockRendering.InputRow): void;
/**
* Add spacers between rows and set their sizes.
* @protected
*/
addRowSpacing_(): void;
/**
* Create a spacer row to go between prev and next, and set its size.
* @param {!Blockly.blockRendering.Row} prev The previous row.
* @param {!Blockly.blockRendering.Row} next The next row.
* @return {!Blockly.blockRendering.SpacerRow} The newly created spacer row.
* @protected
*/
makeSpacerRow_(prev: Blockly.blockRendering.Row, next: Blockly.blockRendering.Row): Blockly.blockRendering.SpacerRow;
/**
* Calculate the width of a spacer row.
* @param {!Blockly.blockRendering.Row} _prev The row before the spacer.
* @param {!Blockly.blockRendering.Row} _next The row after the spacer.
* @return {number} The desired width of the spacer row between these two rows.
* @protected
*/
getSpacerRowWidth_(_prev: Blockly.blockRendering.Row, _next: Blockly.blockRendering.Row): number;
/**
* Calculate the height of a spacer row.
* @param {!Blockly.blockRendering.Row} _prev The row before the spacer.
* @param {!Blockly.blockRendering.Row} _next The row after the spacer.
* @return {number} The desired height of the spacer row between these two rows.
* @protected
*/
getSpacerRowHeight_(_prev: Blockly.blockRendering.Row, _next: Blockly.blockRendering.Row): number;
/**
* Calculate the centerline of an element in a rendered row.
* This base implementation puts the centerline at the middle of the row
* vertically, with no special cases. You will likely need extra logic to
* handle (at minimum) top and bottom rows.
* @param {!Blockly.blockRendering.Row} row The row containing the element.
* @param {!Blockly.blockRendering.Measurable} elem The element to place.
* @return {number} The desired centerline of the given element, as an offset
* from the top left of the block.
* @protected
*/
getElemCenterline_(row: Blockly.blockRendering.Row, elem: Blockly.blockRendering.Measurable): number;
/**
* Record final position information on elements on the given row, for use in
* drawing. At minimum this records xPos and centerline on each element.
* @param {!Blockly.blockRendering.Row} row The row containing the elements.
* @protected
*/
recordElemPositions_(row: Blockly.blockRendering.Row): void;
/**
* Make any final changes to the rendering information object. In particular,
* store the y position of each row, and record the height of the full block.
* @protected
*/
finalize_(): void;
}
}
declare module Blockly.blockRendering {
class MarkerSvg extends MarkerSvg__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class MarkerSvg__Class {
/**
* Class for a marker.
* @param {!Blockly.WorkspaceSvg} workspace The workspace the marker belongs to.
* @param {!Blockly.blockRendering.ConstantProvider} constants The constants for
* the renderer.
* @param {!Blockly.Marker} marker The marker to draw.
* @constructor
*/
constructor(workspace: Blockly.WorkspaceSvg, constants: Blockly.blockRendering.ConstantProvider, marker: Blockly.Marker);
/**
* The constants necessary to draw the marker.
* @type {Blockly.blockRendering.ConstantProvider}
* @protected
*/
constants_: Blockly.blockRendering.ConstantProvider;
/**
* The current SVG element for the marker.
* @type {Element}
*/
currentMarkerSvg: Element;
/**
* The colour of the marker.
* @type {string}
*/
colour_: string;
/**
* Return the root node of the SVG or null if none exists.
* @return {SVGElement} The root SVG node.
*/
getSvgRoot(): SVGElement;
/**
* Get the marker.
* @return {!Blockly.Marker} The marker to draw for.
*/
getMarker(): Blockly.Marker;
/**
* True if the marker should be drawn as a cursor, false otherwise.
* A cursor is drawn as a flashing line. A marker is drawn as a solid line.
* @return {boolean} True if the marker is a cursor, false otherwise.
*/
isCursor(): boolean;
/**
* Create the DOM element for the marker.
* @return {!SVGElement} The marker controls SVG group.
* @package
*/
createDom(): SVGElement;
/**
* Attaches the SVG root of the marker to the SVG group of the parent.
* @param {!Blockly.IASTNodeLocationSvg} newParent The workspace, field, or
* block that the marker SVG element should be attached to.
* @protected
*/
setParent_(newParent: Blockly.IASTNodeLocationSvg): void;
/**
* Update the marker.
* @param {Blockly.ASTNode} oldNode The previous node the marker was on or null.
* @param {Blockly.ASTNode} curNode The node that we want to draw the marker for.
*/
draw(oldNode: Blockly.ASTNode, curNode: Blockly.ASTNode): void;
/**
* Update the marker's visible state based on the type of curNode..
* @param {!Blockly.ASTNode} curNode The node that we want to draw the marker for.
* @protected
*/
showAtLocation_(curNode: Blockly.ASTNode): void;
/**
* Position and display the marker for a block.
* @param {!Blockly.ASTNode} curNode The node to draw the marker for.
* @protected
*/
showWithBlock_(curNode: Blockly.ASTNode): void;
/**
* Position and display the marker for a previous connection.
* @param {!Blockly.ASTNode} curNode The node to draw the marker for.
* @protected
*/
showWithPrevious_(curNode: Blockly.ASTNode): void;
/**
* Position and display the marker for an output connection.
* @param {!Blockly.ASTNode} curNode The node to draw the marker for.
* @protected
*/
showWithOutput_(curNode: Blockly.ASTNode): void;
/**
* Position and display the marker for a workspace coordinate.
* This is a horizontal line.
* @param {!Blockly.ASTNode} curNode The node to draw the marker for.
* @protected
*/
showWithCoordinates_(curNode: Blockly.ASTNode): void;
/**
* Position and display the marker for a field.
* This is a box around the field.
* @param {!Blockly.ASTNode} curNode The node to draw the marker for.
* @protected
*/
showWithField_(curNode: Blockly.ASTNode): void;
/**
* Position and display the marker for an input.
* This is a puzzle piece.
* @param {!Blockly.ASTNode} curNode The node to draw the marker for.
* @protected
*/
showWithInput_(curNode: Blockly.ASTNode): void;
/**
* Position and display the marker for a next connection.
* This is a horizontal line.
* @param {!Blockly.ASTNode} curNode The node to draw the marker for.
* @protected
*/
showWithNext_(curNode: Blockly.ASTNode): void;
/**
* Position and display the marker for a stack.
* This is a box with extra padding around the entire stack of blocks.
* @param {!Blockly.ASTNode} curNode The node to draw the marker for.
* @protected
*/
showWithStack_(curNode: Blockly.ASTNode): void;
/**
* Show the current marker.
* @protected
*/
showCurrent_(): void;
/**
* Position the marker for a block.
* Displays an outline of the top half of a rectangle around a block.
* @param {number} width The width of the block.
* @param {number} markerOffset The extra padding for around the block.
* @param {number} markerHeight The height of the marker.
* @protected
*/
positionBlock_(width: number, markerOffset: number, markerHeight: number): void;
/**
* Position the marker for an input connection.
* Displays a filled in puzzle piece.
* @param {!Blockly.RenderedConnection} connection The connection to position
* marker around.
* @protected
*/
positionInput_(connection: Blockly.RenderedConnection): void;
/**
* Move and show the marker at the specified coordinate in workspace units.
* Displays a horizontal line.
* @param {number} x The new x, in workspace units.
* @param {number} y The new y, in workspace units.
* @param {number} width The new width, in workspace units.
* @protected
*/
positionLine_(x: number, y: number, width: number): void;
/**
* Position the marker for an output connection.
* Displays a puzzle outline and the top and bottom path.
* @param {number} width The width of the block.
* @param {number} height The height of the block.
* @param {!Object} connectionShape The shape object for the connection.
* @protected
*/
positionOutput_(width: number, height: number, connectionShape: Object): void;
/**
* Position the marker for a previous connection.
* Displays a half rectangle with a notch in the top to represent the previous
* connection.
* @param {number} width The width of the block.
* @param {number} markerOffset The offset of the marker from around the block.
* @param {number} markerHeight The height of the marker.
* @param {!Object} connectionShape The shape object for the connection.
* @protected
*/
positionPrevious_(width: number, markerOffset: number, markerHeight: number, connectionShape: Object): void;
/**
* Move and show the marker at the specified coordinate in workspace units.
* Displays a filled in rectangle.
* @param {number} x The new x, in workspace units.
* @param {number} y The new y, in workspace units.
* @param {number} width The new width, in workspace units.
* @param {number} height The new height, in workspace units.
* @protected
*/
positionRect_(x: number, y: number, width: number, height: number): void;
/**
* Hide the marker.
*/
hide(): void;
/**
* Get the properties to make a marker blink.
* @return {!Object} The object holding attributes to make the marker blink.
* @protected
*/
getBlinkProperties_(): Object;
/**
* Create the marker SVG.
* @return {Element} The SVG node created.
* @protected
*/
createDomInternal_(): Element;
/**
* Apply the marker's colour.
* @param {!Blockly.ASTNode} _curNode The node that we want to draw the marker
* for.
* @protected
*/
applyColour_(_curNode: Blockly.ASTNode): void;
/**
* Dispose of this marker.
*/
dispose(): void;
}
}
declare module Blockly.blockRendering.MarkerSvg {
/**
* The name of the CSS class for a cursor.
* @const {string}
*/
var CURSOR_CLASS: any /*missing*/;
/**
* The name of the CSS class for a marker.
* @const {string}
*/
var MARKER_CLASS: any /*missing*/;
/**
* What we multiply the height by to get the height of the marker.
* Only used for the block and block connections.
* @const {number}
*/
var HEIGHT_MULTIPLIER: any /*missing*/;
}
declare module Blockly.blockRendering {
class PathObject extends PathObject__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class PathObject__Class implements Blockly.blockRendering.IPathObject {
/**
* An object that handles creating and setting each of the SVG elements
* used by the renderer.
* @param {!SVGElement} root The root SVG element.
* @param {!Blockly.Theme.BlockStyle} style The style object to use for
* colouring.
* @param {!Blockly.blockRendering.ConstantProvider} constants The renderer's
* constants.
* @constructor
* @implements {Blockly.blockRendering.IPathObject}
* @package
*/
constructor(root: SVGElement, style: Blockly.Theme.BlockStyle, constants: Blockly.blockRendering.ConstantProvider);
/**
* The renderer's constant provider.
* @type {!Blockly.blockRendering.ConstantProvider}
* @package
*/
constants: Blockly.blockRendering.ConstantProvider;
/**
* The primary path of the block.
* @type {!SVGElement}
* @package
*/
svgPath: SVGElement;
/**
* The style object to use when colouring block paths.
* @type {!Blockly.Theme.BlockStyle}
* @package
*/
style: Blockly.Theme.BlockStyle;
/**
* Holds the cursors svg element when the cursor is attached to the block.
* This is null if there is no cursor on the block.
* @type {SVGElement}
* @package
*/
cursorSvg: SVGElement;
/**
* Holds the markers svg element when the marker is attached to the block.
* This is null if there is no marker on the block.
* @type {SVGElement}
* @package
*/
markerSvg: SVGElement;
/**
* Set the path generated by the renderer onto the respective SVG element.
* @param {string} pathString The path.
* @package
*/
setPath(pathString: string): void;
/**
* Flip the SVG paths in RTL.
* @package
*/
flipRTL(): void;
/**
* Add the cursor SVG to this block's SVG group.
* @param {SVGElement} cursorSvg The SVG root of the cursor to be added to the
* block SVG group.
* @package
*/
setCursorSvg(cursorSvg: SVGElement): void;
/**
* Add the marker SVG to this block's SVG group.
* @param {SVGElement} markerSvg The SVG root of the marker to be added to the
* block SVG group.
* @package
*/
setMarkerSvg(markerSvg: SVGElement): void;
/**
* Apply the stored colours to the block's path, taking into account whether
* the paths belong to a shadow block.
* @param {!Blockly.Block} block The source block.
* @package
*/
applyColour(block: Blockly.Block): void;
/**
* Set the style.
* @param {!Blockly.Theme.BlockStyle} blockStyle The block style to use.
* @package
*/
setStyle(blockStyle: Blockly.Theme.BlockStyle): void;
/**
* Add or remove the given CSS class on the path object's root SVG element.
* @param {string} className The name of the class to add or remove
* @param {boolean} add True if the class should be added. False if it should
* be removed.
* @protected
*/
setClass_(className: string, add: boolean): void;
/**
* Set whether the block shows a highlight or not. Block highlighting is
* often used to visually mark blocks currently being executed.
* @param {boolean} enable True if highlighted.
* @package
*/
updateHighlighted(enable: boolean): void;
/**
* Updates the look of the block to reflect a shadow state.
* @param {boolean} shadow True if the block is a shadow block.
* @protected
*/
updateShadow_(shadow: boolean): void;
/**
* Updates the look of the block to reflect a disabled state.
* @param {boolean} disabled True if disabled.
* @protected
*/
updateDisabled_(disabled: boolean): void;
/**
* Add or remove styling showing that a block is selected.
* @param {boolean} enable True if selection is enabled, false otherwise.
* @package
*/
updateSelected(enable: boolean): void;
/**
* Add or remove styling showing that a block is dragged over a delete area.
* @param {boolean} enable True if the block is being dragged over a delete
* area, false otherwise.
* @package
*/
updateDraggingDelete(enable: boolean): void;
/**
* Add or remove styling showing that a block is an insertion marker.
* @param {boolean} enable True if the block is an insertion marker, false
* otherwise.
* @package
*/
updateInsertionMarker(enable: boolean): void;
/**
* Add or remove styling showing that a block is movable.
* @param {boolean} enable True if the block is movable, false otherwise.
* @package
*/
updateMovable(enable: boolean): void;
/**
* Add or remove styling that shows that if the dragging block is dropped, this
* block will be replaced. If a shadow block, it will disappear. Otherwise it
* will bump.
* @param {boolean} enable True if styling should be added.
* @package
*/
updateReplacementFade(enable: boolean): void;
/**
* Add or remove styling that shows that if the dragging block is dropped, this
* block will be connected to the input.
* @param {Blockly.Connection} _conn The connection on the input to highlight.
* @param {boolean} _enable True if styling should be added.
* @package
*/
updateShapeForInputHighlight(_conn: Blockly.Connection, _enable: boolean): void;
}
}
declare module Blockly.blockRendering {
class Renderer extends Renderer__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Renderer__Class implements Blockly.IRegistrable {
/**
* The base class for a block renderer.
* @param {string} name The renderer name.
* @package
* @constructor
* @implements {Blockly.IRegistrable}
*/
constructor(name: string);
/**
* The renderer name.
* @type {string}
* @package
*/
name: string;
/**
* Rendering constant overrides, passed in through options.
* @type {?Object}
* @package
*/
overrides: Object;
/**
* Gets the class name that identifies this renderer.
* @return {string} The CSS class name.
* @package
*/
getClassName(): string;
/**
* Initialize the renderer.
* @param {!Blockly.Theme} theme The workspace theme object.
* @param {Object=} opt_rendererOverrides Rendering constant overrides.
* @package
*/
init(theme: Blockly.Theme, opt_rendererOverrides?: Object): void;
/**
* Create any DOM elements that this renderer needs.
* @param {!SVGElement} svg The root of the workspace's SVG.
* @param {!Blockly.Theme} theme The workspace theme object.
* @package
*/
createDom(svg: SVGElement, theme: Blockly.Theme): void;
/**
* Refresh the renderer after a theme change.
* @param {!SVGElement} svg The root of the workspace's SVG.
* @param {!Blockly.Theme} theme The workspace theme object.
* @package
*/
refreshDom(svg: SVGElement, theme: Blockly.Theme): void;
/**
* Dispose of this renderer.
* Delete all DOM elements that this renderer and its constants created.
* @package
*/
dispose(): void;
/**
* Create a new instance of the renderer's constant provider.
* @return {!Blockly.blockRendering.ConstantProvider} The constant provider.
* @protected
*/
makeConstants_(): Blockly.blockRendering.ConstantProvider;
/**
* Create a new instance of the renderer's render info object.
* @param {!Blockly.BlockSvg} block The block to measure.
* @return {!Blockly.blockRendering.RenderInfo} The render info object.
* @protected
*/
makeRenderInfo_(block: Blockly.BlockSvg): Blockly.blockRendering.RenderInfo;
/**
* Create a new instance of the renderer's drawer.
* @param {!Blockly.BlockSvg} block The block to render.
* @param {!Blockly.blockRendering.RenderInfo} info An object containing all
* information needed to render this block.
* @return {!Blockly.blockRendering.Drawer} The drawer.
* @protected
*/
makeDrawer_(block: Blockly.BlockSvg, info: Blockly.blockRendering.RenderInfo): Blockly.blockRendering.Drawer;
/**
* Create a new instance of the renderer's debugger.
* @return {!Blockly.blockRendering.Debug} The renderer debugger.
* @suppress {strictModuleDepCheck} Debug renderer only included in playground.
* @protected
*/
makeDebugger_(): Blockly.blockRendering.Debug;
/**
* Create a new instance of the renderer's marker drawer.
* @param {!Blockly.WorkspaceSvg} workspace The workspace the marker belongs to.
* @param {!Blockly.Marker} marker The marker.
* @return {!Blockly.blockRendering.MarkerSvg} The object in charge of drawing
* the marker.
* @package
*/
makeMarkerDrawer(workspace: Blockly.WorkspaceSvg, marker: Blockly.Marker): Blockly.blockRendering.MarkerSvg;
/**
* Create a new instance of a renderer path object.
* @param {!SVGElement} root The root SVG element.
* @param {!Blockly.Theme.BlockStyle} style The style object to use for
* colouring.
* @return {!Blockly.blockRendering.IPathObject} The renderer path object.
* @package
*/
makePathObject(root: SVGElement, style: Blockly.Theme.BlockStyle): Blockly.blockRendering.IPathObject;
/**
* Get the current renderer's constant provider. We assume that when this is
* called, the renderer has already been initialized.
* @return {!Blockly.blockRendering.ConstantProvider} The constant provider.
* @package
*/
getConstants(): Blockly.blockRendering.ConstantProvider;
/**
* Determine whether or not to highlight a connection.
* @param {Blockly.Connection} _conn The connection to determine whether or not
* to highlight.
* @return {boolean} True if we should highlight the connection.
* @package
*/
shouldHighlightConnection(_conn: Blockly.Connection): boolean;
/**
* Checks if an orphaned block can connect to the "end" of the topBlock's
* block-clump. If the clump is a row the end is the last input. If the clump
* is a stack, the end is the last next connection. If the clump is neither,
* then this returns false.
* @param {!Blockly.BlockSvg} topBlock The top block of the block clump we want to try and
* connect to.
* @param {!Blockly.BlockSvg} orphanBlock The orphan block that wants to find
* a home.
* @param {number} localType The type of the connection being dragged.
* @return {boolean} Whether there is a home for the orphan or not.
* @package
*/
orphanCanConnectAtEnd(topBlock: Blockly.BlockSvg, orphanBlock: Blockly.BlockSvg, localType: number): boolean;
/**
* Chooses a connection preview method based on the available connection, the
* current dragged connection, and the block being dragged.
* @param {!Blockly.RenderedConnection} closest The available connection.
* @param {!Blockly.RenderedConnection} local The connection currently being
* dragged.
* @param {!Blockly.BlockSvg} topBlock The block currently being dragged.
* @return {!Blockly.InsertionMarkerManager.PREVIEW_TYPE} The preview type
* to display.
* @package
*/
getConnectionPreviewMethod(closest: Blockly.RenderedConnection, local: Blockly.RenderedConnection, topBlock: Blockly.BlockSvg): Blockly.InsertionMarkerManager.PREVIEW_TYPE;
/**
* Render the block.
* @param {!Blockly.BlockSvg} block The block to render.
* @package
*/
render(block: Blockly.BlockSvg): void;
}
}
declare module Blockly.blockRendering {
class Measurable extends Measurable__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Measurable__Class {
/**
* The base class to represent a part of a block that takes up space during
* rendering. The constructor for each non-spacer Measurable records the size
* of the block element (e.g. field, statement input).
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @package
* @constructor
*/
constructor(constants: Blockly.blockRendering.ConstantProvider);
/**
* The renderer's constant provider.
* @type {!Blockly.blockRendering.ConstantProvider}
* @protected
*/
constants_: Blockly.blockRendering.ConstantProvider;
}
}
declare module Blockly.blockRendering {
class Connection extends Connection__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Connection__Class extends Blockly.blockRendering.Measurable__Class {
/**
* The base class to represent a connection and the space that it takes up on
* the block.
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @param {!Blockly.RenderedConnection} connectionModel The connection object on
* the block that this represents.
* @package
* @constructor
* @extends {Blockly.blockRendering.Measurable}
*/
constructor(constants: Blockly.blockRendering.ConstantProvider, connectionModel: Blockly.RenderedConnection);
}
class OutputConnection extends OutputConnection__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class OutputConnection__Class extends Blockly.blockRendering.Connection__Class {
/**
* An object containing information about the space an output connection takes
* up during rendering.
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @param {Blockly.RenderedConnection} connectionModel The connection object on
* the block that this represents.
* @package
* @constructor
* @extends {Blockly.blockRendering.Connection}
*/
constructor(constants: Blockly.blockRendering.ConstantProvider, connectionModel: Blockly.RenderedConnection);
}
class PreviousConnection extends PreviousConnection__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class PreviousConnection__Class extends Blockly.blockRendering.Connection__Class {
/**
* An object containing information about the space a previous connection takes
* up during rendering.
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @param {Blockly.RenderedConnection} connectionModel The connection object on
* the block that this represents.
* @package
* @constructor
* @extends {Blockly.blockRendering.Connection}
*/
constructor(constants: Blockly.blockRendering.ConstantProvider, connectionModel: Blockly.RenderedConnection);
}
class NextConnection extends NextConnection__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class NextConnection__Class extends Blockly.blockRendering.Connection__Class {
/**
* An object containing information about the space a next connection takes
* up during rendering.
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @param {Blockly.RenderedConnection} connectionModel The connection object on
* the block that this represents.
* @package
* @constructor
* @extends {Blockly.blockRendering.Connection}
*/
constructor(constants: Blockly.blockRendering.ConstantProvider, connectionModel: Blockly.RenderedConnection);
}
}
declare module Blockly.blockRendering {
class InputConnection extends InputConnection__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class InputConnection__Class extends Blockly.blockRendering.Connection__Class {
/**
* The base class to represent an input that takes up space on a block
* during rendering
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @param {!Blockly.Input} input The input to measure and store information for.
* @package
* @constructor
* @extends {Blockly.blockRendering.Connection}
*/
constructor(constants: Blockly.blockRendering.ConstantProvider, input: Blockly.Input);
}
class InlineInput extends InlineInput__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class InlineInput__Class extends Blockly.blockRendering.InputConnection__Class {
/**
* An object containing information about the space an inline input takes up
* during rendering
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @param {!Blockly.Input} input The inline input to measure and store
* information for.
* @package
* @constructor
* @extends {Blockly.blockRendering.InputConnection}
*/
constructor(constants: Blockly.blockRendering.ConstantProvider, input: Blockly.Input);
}
class StatementInput extends StatementInput__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class StatementInput__Class extends Blockly.blockRendering.InputConnection__Class {
/**
* An object containing information about the space a statement input takes up
* during rendering
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @param {!Blockly.Input} input The statement input to measure and store
* information for.
* @package
* @constructor
* @extends {Blockly.blockRendering.InputConnection}
*/
constructor(constants: Blockly.blockRendering.ConstantProvider, input: Blockly.Input);
}
class ExternalValueInput extends ExternalValueInput__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class ExternalValueInput__Class extends Blockly.blockRendering.InputConnection__Class {
/**
* An object containing information about the space an external value input
* takes up during rendering
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @param {!Blockly.Input} input The external value input to measure and store
* information for.
* @package
* @constructor
* @extends {Blockly.blockRendering.InputConnection}
*/
constructor(constants: Blockly.blockRendering.ConstantProvider, input: Blockly.Input);
}
}
declare module Blockly.blockRendering {
class Icon extends Icon__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Icon__Class extends Blockly.blockRendering.Measurable__Class {
/**
* An object containing information about the space an icon takes up during
* rendering
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @param {!Blockly.Icon} icon The icon to measure and store information for.
* @package
* @constructor
* @extends {Blockly.blockRendering.Measurable}
*/
constructor(constants: Blockly.blockRendering.ConstantProvider, icon: Blockly.Icon);
}
class JaggedEdge extends JaggedEdge__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class JaggedEdge__Class extends Blockly.blockRendering.Measurable__Class {
/**
* An object containing information about the jagged edge of a collapsed block
* takes up during rendering
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @package
* @constructor
* @extends {Blockly.blockRendering.Measurable}
*/
constructor(constants: Blockly.blockRendering.ConstantProvider);
}
class Field extends Field__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Field__Class extends Blockly.blockRendering.Measurable__Class {
/**
* An object containing information about the space a field takes up during
* rendering
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @param {!Blockly.Field} field The field to measure and store information for.
* @param {!Blockly.Input} parentInput The parent input for the field.
* @package
* @constructor
* @extends {Blockly.blockRendering.Measurable}
*/
constructor(constants: Blockly.blockRendering.ConstantProvider, field: Blockly.Field, parentInput: Blockly.Input);
}
class Hat extends Hat__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Hat__Class extends Blockly.blockRendering.Measurable__Class {
/**
* An object containing information about the space a hat takes up during
* rendering.
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @package
* @constructor
* @extends {Blockly.blockRendering.Measurable}
*/
constructor(constants: Blockly.blockRendering.ConstantProvider);
}
class SquareCorner extends SquareCorner__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class SquareCorner__Class extends Blockly.blockRendering.Measurable__Class {
/**
* An object containing information about the space a square corner takes up
* during rendering.
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @param {string=} opt_position The position of this corner.
* @package
* @constructor
* @extends {Blockly.blockRendering.Measurable}
*/
constructor(constants: Blockly.blockRendering.ConstantProvider, opt_position?: string);
}
class RoundCorner extends RoundCorner__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class RoundCorner__Class extends Blockly.blockRendering.Measurable__Class {
/**
* An object containing information about the space a rounded corner takes up
* during rendering.
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @param {string=} opt_position The position of this corner.
* @package
* @constructor
* @extends {Blockly.blockRendering.Measurable}
*/
constructor(constants: Blockly.blockRendering.ConstantProvider, opt_position?: string);
}
class InRowSpacer extends InRowSpacer__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class InRowSpacer__Class extends Blockly.blockRendering.Measurable__Class {
/**
* An object containing information about a spacer between two elements on a
* row.
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @param {number} width The width of the spacer.
* @package
* @constructor
* @extends {Blockly.blockRendering.Measurable}
*/
constructor(constants: Blockly.blockRendering.ConstantProvider, width: number);
}
}
declare module Blockly.blockRendering {
class Row extends Row__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Row__Class {
/**
* An object representing a single row on a rendered block and all of its
* subcomponents.
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @package
* @constructor
*/
constructor(constants: Blockly.blockRendering.ConstantProvider);
/**
* The type of this rendering object.
* @package
* @type {number}
*/
type: number;
/**
* An array of elements contained in this row.
* @package
* @type {!Array<!Blockly.blockRendering.Measurable>}
*/
elements: Blockly.blockRendering.Measurable[];
/**
* The height of the row.
* @package
* @type {number}
*/
height: number;
/**
* The width of the row, from the left edge of the block to the right.
* Does not include child blocks unless they are inline.
* @package
* @type {number}
*/
width: number;
/**
* The minimum height of the row.
* @package
* @type {number}
*/
minHeight: number;
/**
* The minimum width of the row, from the left edge of the block to the right.
* Does not include child blocks unless they are inline.
* @package
* @type {number}
*/
minWidth: number;
/**
* The width of the row, from the left edge of the block to the edge of the
* block or any connected child blocks.
* @package
* @type {number}
*/
widthWithConnectedBlocks: number;
/**
* The Y position of the row relative to the origin of the block's svg group.
* @package
* @type {number}
*/
yPos: number;
/**
* The X position of the row relative to the origin of the block's svg group.
* @package
* @type {number}
*/
xPos: number;
/**
* Whether the row has any external inputs.
* @package
* @type {boolean}
*/
hasExternalInput: boolean;
/**
* Whether the row has any statement inputs.
* @package
* @type {boolean}
*/
hasStatement: boolean;
/**
* Whether the row has any inline inputs.
* @package
* @type {boolean}
*/
hasInlineInput: boolean;
/**
* Whether the row has any dummy inputs.
* @package
* @type {boolean}
*/
hasDummyInput: boolean;
/**
* Whether the row has a jagged edge.
* @package
* @type {boolean}
*/
hasJaggedEdge: boolean;
/**
* The renderer's constant provider.
* @type {!Blockly.blockRendering.ConstantProvider}
* @protected
*/
constants_: Blockly.blockRendering.ConstantProvider;
/**
* Alignment of the row.
* @package
* @type {?number}
*/
align: number;
/**
* Inspect all subcomponents and populate all size properties on the row.
* @package
*/
measure(): void;
/**
* Get the last input on this row, if it has one.
* @return {Blockly.blockRendering.InputConnection} The last input on the row,
* or null.
* @package
*/
getLastInput(): Blockly.blockRendering.InputConnection;
/**
* Determines whether this row should start with an element spacer.
* @return {boolean} Whether the row should start with a spacer.
* @package
*/
startsWithElemSpacer(): boolean;
/**
* Determines whether this row should end with an element spacer.
* @return {boolean} Whether the row should end with a spacer.
* @package
*/
endsWithElemSpacer(): boolean;
/**
* Convenience method to get the first spacer element on this row.
* @return {Blockly.blockRendering.InRowSpacer} The first spacer element on
* this row.
* @package
*/
getFirstSpacer(): Blockly.blockRendering.InRowSpacer;
/**
* Convenience method to get the last spacer element on this row.
* @return {Blockly.blockRendering.InRowSpacer} The last spacer element on
* this row.
* @package
*/
getLastSpacer(): Blockly.blockRendering.InRowSpacer;
}
class TopRow extends TopRow__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class TopRow__Class extends Blockly.blockRendering.Row__Class {
/**
* An object containing information about what elements are in the top row of a
* block as well as sizing information for the top row.
* Elements in a top row can consist of corners, hats, spacers, and previous
* connections.
* After this constructor is called, the row will contain all non-spacer
* elements it needs.
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @package
* @constructor
* @extends {Blockly.blockRendering.Row}
*/
constructor(constants: Blockly.blockRendering.ConstantProvider);
/**
* The starting point for drawing the row, in the y direction.
* This allows us to draw hats and similar shapes that don't start at the
* origin. Must be non-negative (see #2820).
* @package
* @type {number}
*/
capline: number;
/**
* How much the row extends up above its capline.
* @type {number}
*/
ascenderHeight: number;
/**
* Whether the block has a previous connection.
* @package
* @type {boolean}
*/
hasPreviousConnection: boolean;
/**
* The previous connection on the block, if any.
* @type {Blockly.blockRendering.PreviousConnection}
*/
connection: Blockly.blockRendering.PreviousConnection;
/**
* Returns whether or not the top row has a left square corner.
* @param {!Blockly.BlockSvg} block The block whose top row this represents.
* @return {boolean} Whether or not the top row has a left square corner.
*/
hasLeftSquareCorner(block: Blockly.BlockSvg): boolean;
/**
* Returns whether or not the top row has a right square corner.
* @param {!Blockly.BlockSvg} _block The block whose top row this represents.
* @return {boolean} Whether or not the top row has a right square corner.
*/
hasRightSquareCorner(_block: Blockly.BlockSvg): boolean;
}
class BottomRow extends BottomRow__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class BottomRow__Class extends Blockly.blockRendering.Row__Class {
/**
* An object containing information about what elements are in the bottom row of
* a block as well as spacing information for the top row.
* Elements in a bottom row can consist of corners, spacers and next
* connections.
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @package
* @constructor
* @extends {Blockly.blockRendering.Row}
*/
constructor(constants: Blockly.blockRendering.ConstantProvider);
/**
* Whether this row has a next connection.
* @package
* @type {boolean}
*/
hasNextConnection: boolean;
/**
* The next connection on the row, if any.
* @package
* @type {Blockly.blockRendering.NextConnection}
*/
connection: Blockly.blockRendering.NextConnection;
/**
* The amount that the bottom of the block extends below the horizontal edge,
* e.g. because of a next connection. Must be non-negative (see #2820).
* @package
* @type {number}
*/
descenderHeight: number;
/**
* The Y position of the bottom edge of the block, relative to the origin
* of the block rendering.
* @type {number}
*/
baseline: number;
/**
* Returns whether or not the bottom row has a left square corner.
* @param {!Blockly.BlockSvg} block The block whose bottom row this represents.
* @return {boolean} Whether or not the bottom row has a left square corner.
*/
hasLeftSquareCorner(block: Blockly.BlockSvg): boolean;
/**
* Returns whether or not the bottom row has a right square corner.
* @param {!Blockly.BlockSvg} _block The block whose bottom row this represents.
* @return {boolean} Whether or not the bottom row has a right square corner.
*/
hasRightSquareCorner(_block: Blockly.BlockSvg): boolean;
}
class SpacerRow extends SpacerRow__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class SpacerRow__Class extends Blockly.blockRendering.Row__Class {
/**
* An object containing information about a spacer between two rows.
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @param {number} height The height of the spacer.
* @param {number} width The width of the spacer.
* @package
* @constructor
* @extends {Blockly.blockRendering.Row}
*/
constructor(constants: Blockly.blockRendering.ConstantProvider, height: number, width: number);
}
class InputRow extends InputRow__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class InputRow__Class extends Blockly.blockRendering.Row__Class {
/**
* An object containing information about a row that holds one or more inputs.
* @param {!Blockly.blockRendering.ConstantProvider} constants The rendering
* constants provider.
* @package
* @constructor
* @extends {Blockly.blockRendering.Row}
*/
constructor(constants: Blockly.blockRendering.ConstantProvider);
/**
* The total width of all blocks connected to this row.
* @type {number}
* @package
*/
connectedBlockWidths: number;
/**
* Inspect all subcomponents and populate all size properties on the row.
* @package
*/
measure(): void;
}
}
declare module Blockly.blockRendering {
/**
* Types of rendering elements.
* @enum {number}
*/
enum Types { NONE, FIELD, HAT, ICON, SPACER, BETWEEN_ROW_SPACER, IN_ROW_SPACER, EXTERNAL_VALUE_INPUT, INPUT, INLINE_INPUT, STATEMENT_INPUT, CONNECTION, PREVIOUS_CONNECTION, NEXT_CONNECTION, OUTPUT_CONNECTION, CORNER, LEFT_SQUARE_CORNER, LEFT_ROUND_CORNER, RIGHT_SQUARE_CORNER, RIGHT_ROUND_CORNER, JAGGED_EDGE, ROW, TOP_ROW, BOTTOM_ROW, INPUT_ROW }
}
declare module Blockly.blockRendering.Types {
/**
* A Left Corner Union Type.
* @type {number}
* @const
* @package
*/
var LEFT_CORNER: number;
/**
* A Right Corner Union Type.
* @type {number}
* @const
* @package
*/
var RIGHT_CORNER: number;
/**
* Get the enum flag value of an existing type or register a new type.
* @param {!string} type The name of the type.
* @return {!number} The enum flag value associated with that type.
* @package
*/
function getType(type: string): number;
/**
* Whether a measurable stores information about a field.
* @param {!Blockly.blockRendering.Measurable} elem The element to check.
* @return {number} 1 if the object stores information about a field.
* @package
*/
function isField(elem: Blockly.blockRendering.Measurable): number;
/**
* Whether a measurable stores information about a hat.
* @param {!Blockly.blockRendering.Measurable} elem The element to check.
* @return {number} 1 if the object stores information about a hat.
* @package
*/
function isHat(elem: Blockly.blockRendering.Measurable): number;
/**
* Whether a measurable stores information about an icon.
* @param {!Blockly.blockRendering.Measurable} elem The element to check.
* @return {number} 1 if the object stores information about an icon.
* @package
*/
function isIcon(elem: Blockly.blockRendering.Measurable): number;
/**
* Whether a measurable stores information about a spacer.
* @param {!Blockly.blockRendering.Measurable|!Blockly.blockRendering.Row} elem
* The element to check.
* @return {number} 1 if the object stores information about a spacer.
* @package
*/
function isSpacer(elem: Blockly.blockRendering.Measurable|Blockly.blockRendering.Row): number;
/**
* Whether a measurable stores information about an in-row spacer.
* @param {!Blockly.blockRendering.Measurable} elem The element to check.
* @return {number} 1 if the object stores information about an
* in-row spacer.
* @package
*/
function isInRowSpacer(elem: Blockly.blockRendering.Measurable): number;
/**
* Whether a measurable stores information about an input.
* @param {!Blockly.blockRendering.Measurable} elem The element to check.
* @return {number} 1 if the object stores information about an input.
* @package
*/
function isInput(elem: Blockly.blockRendering.Measurable): number;
/**
* Whether a measurable stores information about an external input.
* @param {!Blockly.blockRendering.Measurable} elem The element to check.
* @return {number} 1 if the object stores information about an
* external input.
* @package
*/
function isExternalInput(elem: Blockly.blockRendering.Measurable): number;
/**
* Whether a measurable stores information about an inline input.
* @param {!Blockly.blockRendering.Measurable} elem The element to check.
* @return {number} 1 if the object stores information about an
* inline input.
* @package
*/
function isInlineInput(elem: Blockly.blockRendering.Measurable): number;
/**
* Whether a measurable stores information about a statement input.
* @param {!Blockly.blockRendering.Measurable} elem The element to check.
* @return {number} 1 if the object stores information about a
* statement input.
* @package
*/
function isStatementInput(elem: Blockly.blockRendering.Measurable): number;
/**
* Whether a measurable stores information about a previous connection.
* @param {!Blockly.blockRendering.Measurable} elem The element to check.
* @return {number} 1 if the object stores information about a
* previous connection.
* @package
*/
function isPreviousConnection(elem: Blockly.blockRendering.Measurable): number;
/**
* Whether a measurable stores information about a next connection.
* @param {!Blockly.blockRendering.Measurable} elem The element to check.
* @return {number} 1 if the object stores information about a
* next connection.
* @package
*/
function isNextConnection(elem: Blockly.blockRendering.Measurable): number;
/**
* Whether a measurable stores information about a previous or next connection.
* @param {!Blockly.blockRendering.Measurable} elem The element to check.
* @return {number} 1 if the object stores information about a previous or
* next connection.
* @package
*/
function isPreviousOrNextConnection(elem: Blockly.blockRendering.Measurable): number;
/**
* Whether a measurable stores information about a left round corner.
* @param {!Blockly.blockRendering.Measurable} elem The element to check.
* @return {number} 1 if the object stores information about a
* left round corner.
* @package
*/
function isLeftRoundedCorner(elem: Blockly.blockRendering.Measurable): number;
/**
* Whether a measurable stores information about a right round corner.
* @param {!Blockly.blockRendering.Measurable} elem The element to check.
* @return {number} 1 if the object stores information about a
* right round corner.
* @package
*/
function isRightRoundedCorner(elem: Blockly.blockRendering.Measurable): number;
/**
* Whether a measurable stores information about a left square corner.
* @param {!Blockly.blockRendering.Measurable} elem The element to check.
* @return {number} 1 if the object stores information about a
* left square corner.
* @package
*/
function isLeftSquareCorner(elem: Blockly.blockRendering.Measurable): number;
/**
* Whether a measurable stores information about a right square corner.
* @param {!Blockly.blockRendering.Measurable} elem The element to check.
* @return {number} 1 if the object stores information about a
* right square corner.
* @package
*/
function isRightSquareCorner(elem: Blockly.blockRendering.Measurable): number;
/**
* Whether a measurable stores information about a corner.
* @param {!Blockly.blockRendering.Measurable} elem The element to check.
* @return {number} 1 if the object stores information about a
* corner.
* @package
*/
function isCorner(elem: Blockly.blockRendering.Measurable): number;
/**
* Whether a measurable stores information about a jagged edge.
* @param {!Blockly.blockRendering.Measurable} elem The element to check.
* @return {number} 1 if the object stores information about a jagged edge.
* @package
*/
function isJaggedEdge(elem: Blockly.blockRendering.Measurable): number;
/**
* Whether a measurable stores information about a row.
* @param {!Blockly.blockRendering.Row} row The row to check.
* @return {number} 1 if the object stores information about a row.
* @package
*/
function isRow(row: Blockly.blockRendering.Row): number;
/**
* Whether a measurable stores information about a between-row spacer.
* @param {!Blockly.blockRendering.Row} row The row to check.
* @return {number} 1 if the object stores information about a
* between-row spacer.
* @package
*/
function isBetweenRowSpacer(row: Blockly.blockRendering.Row): number;
/**
* Whether a measurable stores information about a top row.
* @param {!Blockly.blockRendering.Row} row The row to check.
* @return {number} 1 if the object stores information about a top row.
* @package
*/
function isTopRow(row: Blockly.blockRendering.Row): number;
/**
* Whether a measurable stores information about a bottom row.
* @param {!Blockly.blockRendering.Row} row The row to check.
* @return {number} 1 if the object stores information about a bottom row.
* @package
*/
function isBottomRow(row: Blockly.blockRendering.Row): number;
/**
* Whether a measurable stores information about a top or bottom row.
* @param {!Blockly.blockRendering.Row} row The row to check.
* @return {number} 1 if the object stores information about a top or
* bottom row.
* @package
*/
function isTopOrBottomRow(row: Blockly.blockRendering.Row): number;
/**
* Whether a measurable stores information about an input row.
* @param {!Blockly.blockRendering.Row} row The row to check.
* @return {number} 1 if the object stores information about an input row.
* @package
*/
function isInputRow(row: Blockly.blockRendering.Row): number;
}
declare module Blockly.Msg {
/** @type {string} */
var LOGIC_HUE: string;
/** @type {string} */
var LOOPS_HUE: string;
/** @type {string} */
var MATH_HUE: string;
/** @type {string} */
var TEXTS_HUE: string;
/** @type {string} */
var LISTS_HUE: string;
/** @type {string} */
var COLOUR_HUE: string;
/** @type {string} */
var VARIABLES_HUE: string;
/** @type {string} */
var VARIABLES_DYNAMIC_HUE: string;
/** @type {string} */
var PROCEDURES_HUE: string;
/** @type {string} */
var VARIABLES_DEFAULT_NAME: string;
/** @type {string} */
var UNNAMED_KEY: string;
/** @type {string} */
var TODAY: string;
/** @type {string} */
var DUPLICATE_BLOCK: string;
/** @type {string} */
var ADD_COMMENT: string;
/** @type {string} */
var REMOVE_COMMENT: string;
/** @type {string} */
var DUPLICATE_COMMENT: string;
/** @type {string} */
var EXTERNAL_INPUTS: string;
/** @type {string} */
var INLINE_INPUTS: string;
/** @type {string} */
var DELETE_BLOCK: string;
/** @type {string} */
var DELETE_X_BLOCKS: string;
/** @type {string} */
var DELETE_ALL_BLOCKS: string;
/** @type {string} */
var CLEAN_UP: string;
/** @type {string} */
var COLLAPSE_BLOCK: string;
/** @type {string} */
var COLLAPSE_ALL: string;
/** @type {string} */
var EXPAND_BLOCK: string;
/** @type {string} */
var EXPAND_ALL: string;
/** @type {string} */
var DISABLE_BLOCK: string;
/** @type {string} */
var ENABLE_BLOCK: string;
/** @type {string} */
var HELP: string;
/** @type {string} */
var UNDO: string;
/** @type {string} */
var REDO: string;
/** @type {string} */
var CHANGE_VALUE_TITLE: string;
/** @type {string} */
var RENAME_VARIABLE: string;
/** @type {string} */
var RENAME_VARIABLE_TITLE: string;
/** @type {string} */
var NEW_VARIABLE: string;
/** @type {string} */
var NEW_STRING_VARIABLE: string;
/** @type {string} */
var NEW_NUMBER_VARIABLE: string;
/** @type {string} */
var NEW_COLOUR_VARIABLE: string;
/** @type {string} */
var NEW_VARIABLE_TYPE_TITLE: string;
/** @type {string} */
var NEW_VARIABLE_TITLE: string;
/** @type {string} */
var VARIABLE_ALREADY_EXISTS: string;
/** @type {string} */
var VARIABLE_ALREADY_EXISTS_FOR_ANOTHER_TYPE: string;
/** @type {string} */
var DELETE_VARIABLE_CONFIRMATION: string;
/** @type {string} */
var CANNOT_DELETE_VARIABLE_PROCEDURE: string;
/** @type {string} */
var DELETE_VARIABLE: string;
/** @type {string} */
var COLOUR_PICKER_HELPURL: string;
/** @type {string} */
var COLOUR_PICKER_TOOLTIP: string;
/** @type {string} */
var COLOUR_RANDOM_HELPURL: string;
/** @type {string} */
var COLOUR_RANDOM_TITLE: string;
/** @type {string} */
var COLOUR_RANDOM_TOOLTIP: string;
/** @type {string} */
var COLOUR_RGB_HELPURL: string;
/** @type {string} */
var COLOUR_RGB_TITLE: string;
/** @type {string} */
var COLOUR_RGB_RED: string;
/** @type {string} */
var COLOUR_RGB_GREEN: string;
/** @type {string} */
var COLOUR_RGB_BLUE: string;
/** @type {string} */
var COLOUR_RGB_TOOLTIP: string;
/** @type {string} */
var COLOUR_BLEND_HELPURL: string;
/** @type {string} */
var COLOUR_BLEND_TITLE: string;
/** @type {string} */
var COLOUR_BLEND_COLOUR1: string;
/** @type {string} */
var COLOUR_BLEND_COLOUR2: string;
/** @type {string} */
var COLOUR_BLEND_RATIO: string;
/** @type {string} */
var COLOUR_BLEND_TOOLTIP: string;
/** @type {string} */
var CONTROLS_REPEAT_HELPURL: string;
/** @type {string} */
var CONTROLS_REPEAT_TITLE: string;
/** @type {string} */
var CONTROLS_REPEAT_INPUT_DO: string;
/** @type {string} */
var CONTROLS_REPEAT_TOOLTIP: string;
/** @type {string} */
var CONTROLS_WHILEUNTIL_HELPURL: string;
/** @type {string} */
var CONTROLS_WHILEUNTIL_INPUT_DO: string;
/** @type {string} */
var CONTROLS_WHILEUNTIL_OPERATOR_WHILE: string;
/** @type {string} */
var CONTROLS_WHILEUNTIL_OPERATOR_UNTIL: string;
/** @type {string} */
var CONTROLS_WHILEUNTIL_TOOLTIP_WHILE: string;
/** @type {string} */
var CONTROLS_WHILEUNTIL_TOOLTIP_UNTIL: string;
/** @type {string} */
var CONTROLS_FOR_HELPURL: string;
/** @type {string} */
var CONTROLS_FOR_TOOLTIP: string;
/** @type {string} */
var CONTROLS_FOR_TITLE: string;
/** @type {string} */
var CONTROLS_FOR_INPUT_DO: string;
/** @type {string} */
var CONTROLS_FOREACH_HELPURL: string;
/** @type {string} */
var CONTROLS_FOREACH_TITLE: string;
/** @type {string} */
var CONTROLS_FOREACH_INPUT_DO: string;
/** @type {string} */
var CONTROLS_FOREACH_TOOLTIP: string;
/** @type {string} */
var CONTROLS_FLOW_STATEMENTS_HELPURL: string;
/** @type {string} */
var CONTROLS_FLOW_STATEMENTS_OPERATOR_BREAK: string;
/** @type {string} */
var CONTROLS_FLOW_STATEMENTS_OPERATOR_CONTINUE: string;
/** @type {string} */
var CONTROLS_FLOW_STATEMENTS_TOOLTIP_BREAK: string;
/** @type {string} */
var CONTROLS_FLOW_STATEMENTS_TOOLTIP_CONTINUE: string;
/** @type {string} */
var CONTROLS_FLOW_STATEMENTS_WARNING: string;
/** @type {string} */
var CONTROLS_IF_HELPURL: string;
/** @type {string} */
var CONTROLS_IF_TOOLTIP_1: string;
/** @type {string} */
var CONTROLS_IF_TOOLTIP_2: string;
/** @type {string} */
var CONTROLS_IF_TOOLTIP_3: string;
/** @type {string} */
var CONTROLS_IF_TOOLTIP_4: string;
/** @type {string} */
var CONTROLS_IF_MSG_IF: string;
/** @type {string} */
var CONTROLS_IF_MSG_ELSEIF: string;
/** @type {string} */
var CONTROLS_IF_MSG_ELSE: string;
/** @type {string} */
var CONTROLS_IF_MSG_THEN: string;
/** @type {string} */
var CONTROLS_IF_IF_TITLE_IF: string;
/** @type {string} */
var CONTROLS_IF_IF_TOOLTIP: string;
/** @type {string} */
var CONTROLS_IF_ELSEIF_TITLE_ELSEIF: string;
/** @type {string} */
var CONTROLS_IF_ELSEIF_TOOLTIP: string;
/** @type {string} */
var CONTROLS_IF_ELSE_TITLE_ELSE: string;
/** @type {string} */
var CONTROLS_IF_ELSE_TOOLTIP: string;
/** @type {string} */
var IOS_OK: string;
/** @type {string} */
var IOS_CANCEL: string;
/** @type {string} */
var IOS_ERROR: string;
/** @type {string} */
var IOS_PROCEDURES_INPUTS: string;
/** @type {string} */
var IOS_PROCEDURES_ADD_INPUT: string;
/** @type {string} */
var IOS_PROCEDURES_ALLOW_STATEMENTS: string;
/** @type {string} */
var IOS_PROCEDURES_DUPLICATE_INPUTS_ERROR: string;
/** @type {string} */
var IOS_VARIABLES_ADD_VARIABLE: string;
/** @type {string} */
var IOS_VARIABLES_ADD_BUTTON: string;
/** @type {string} */
var IOS_VARIABLES_RENAME_BUTTON: string;
/** @type {string} */
var IOS_VARIABLES_DELETE_BUTTON: string;
/** @type {string} */
var IOS_VARIABLES_VARIABLE_NAME: string;
/** @type {string} */
var IOS_VARIABLES_EMPTY_NAME_ERROR: string;
/** @type {string} */
var LOGIC_COMPARE_HELPURL: string;
/** @type {string} */
var LOGIC_COMPARE_TOOLTIP_EQ: string;
/** @type {string} */
var LOGIC_COMPARE_TOOLTIP_NEQ: string;
/** @type {string} */
var LOGIC_COMPARE_TOOLTIP_LT: string;
/** @type {string} */
var LOGIC_COMPARE_TOOLTIP_LTE: string;
/** @type {string} */
var LOGIC_COMPARE_TOOLTIP_GT: string;
/** @type {string} */
var LOGIC_COMPARE_TOOLTIP_GTE: string;
/** @type {string} */
var LOGIC_OPERATION_HELPURL: string;
/** @type {string} */
var LOGIC_OPERATION_TOOLTIP_AND: string;
/** @type {string} */
var LOGIC_OPERATION_AND: string;
/** @type {string} */
var LOGIC_OPERATION_TOOLTIP_OR: string;
/** @type {string} */
var LOGIC_OPERATION_OR: string;
/** @type {string} */
var LOGIC_NEGATE_HELPURL: string;
/** @type {string} */
var LOGIC_NEGATE_TITLE: string;
/** @type {string} */
var LOGIC_NEGATE_TOOLTIP: string;
/** @type {string} */
var LOGIC_BOOLEAN_HELPURL: string;
/** @type {string} */
var LOGIC_BOOLEAN_TRUE: string;
/** @type {string} */
var LOGIC_BOOLEAN_FALSE: string;
/** @type {string} */
var LOGIC_BOOLEAN_TOOLTIP: string;
/** @type {string} */
var LOGIC_NULL_HELPURL: string;
/** @type {string} */
var LOGIC_NULL: string;
/** @type {string} */
var LOGIC_NULL_TOOLTIP: string;
/** @type {string} */
var LOGIC_TERNARY_HELPURL: string;
/** @type {string} */
var LOGIC_TERNARY_CONDITION: string;
/** @type {string} */
var LOGIC_TERNARY_IF_TRUE: string;
/** @type {string} */
var LOGIC_TERNARY_IF_FALSE: string;
/** @type {string} */
var LOGIC_TERNARY_TOOLTIP: string;
/** @type {string} */
var MATH_NUMBER_HELPURL: string;
/** @type {string} */
var MATH_NUMBER_TOOLTIP: string;
/** @type {string} */
var MATH_ADDITION_SYMBOL: string;
/** @type {string} */
var MATH_SUBTRACTION_SYMBOL: string;
/** @type {string} */
var MATH_DIVISION_SYMBOL: string;
/** @type {string} */
var MATH_MULTIPLICATION_SYMBOL: string;
/** @type {string} */
var MATH_POWER_SYMBOL: string;
/** @type {string} */
var MATH_TRIG_SIN: string;
/** @type {string} */
var MATH_TRIG_COS: string;
/** @type {string} */
var MATH_TRIG_TAN: string;
/** @type {string} */
var MATH_TRIG_ASIN: string;
/** @type {string} */
var MATH_TRIG_ACOS: string;
/** @type {string} */
var MATH_TRIG_ATAN: string;
/** @type {string} */
var MATH_ARITHMETIC_HELPURL: string;
/** @type {string} */
var MATH_ARITHMETIC_TOOLTIP_ADD: string;
/** @type {string} */
var MATH_ARITHMETIC_TOOLTIP_MINUS: string;
/** @type {string} */
var MATH_ARITHMETIC_TOOLTIP_MULTIPLY: string;
/** @type {string} */
var MATH_ARITHMETIC_TOOLTIP_DIVIDE: string;
/** @type {string} */
var MATH_ARITHMETIC_TOOLTIP_POWER: string;
/** @type {string} */
var MATH_SINGLE_HELPURL: string;
/** @type {string} */
var MATH_SINGLE_OP_ROOT: string;
/** @type {string} */
var MATH_SINGLE_TOOLTIP_ROOT: string;
/** @type {string} */
var MATH_SINGLE_OP_ABSOLUTE: string;
/** @type {string} */
var MATH_SINGLE_TOOLTIP_ABS: string;
/** @type {string} */
var MATH_SINGLE_TOOLTIP_NEG: string;
/** @type {string} */
var MATH_SINGLE_TOOLTIP_LN: string;
/** @type {string} */
var MATH_SINGLE_TOOLTIP_LOG10: string;
/** @type {string} */
var MATH_SINGLE_TOOLTIP_EXP: string;
/** @type {string} */
var MATH_SINGLE_TOOLTIP_POW10: string;
/** @type {string} */
var MATH_TRIG_HELPURL: string;
/** @type {string} */
var MATH_TRIG_TOOLTIP_SIN: string;
/** @type {string} */
var MATH_TRIG_TOOLTIP_COS: string;
/** @type {string} */
var MATH_TRIG_TOOLTIP_TAN: string;
/** @type {string} */
var MATH_TRIG_TOOLTIP_ASIN: string;
/** @type {string} */
var MATH_TRIG_TOOLTIP_ACOS: string;
/** @type {string} */
var MATH_TRIG_TOOLTIP_ATAN: string;
/** @type {string} */
var MATH_CONSTANT_HELPURL: string;
/** @type {string} */
var MATH_CONSTANT_TOOLTIP: string;
/** @type {string} */
var MATH_IS_EVEN: string;
/** @type {string} */
var MATH_IS_ODD: string;
/** @type {string} */
var MATH_IS_PRIME: string;
/** @type {string} */
var MATH_IS_WHOLE: string;
/** @type {string} */
var MATH_IS_POSITIVE: string;
/** @type {string} */
var MATH_IS_NEGATIVE: string;
/** @type {string} */
var MATH_IS_DIVISIBLE_BY: string;
/** @type {string} */
var MATH_IS_TOOLTIP: string;
/** @type {string} */
var MATH_CHANGE_HELPURL: string;
/** @type {string} */
var MATH_CHANGE_TITLE: string;
/** @type {string} */
var MATH_CHANGE_TITLE_ITEM: string;
/** @type {string} */
var MATH_CHANGE_TOOLTIP: string;
/** @type {string} */
var MATH_ROUND_HELPURL: string;
/** @type {string} */
var MATH_ROUND_TOOLTIP: string;
/** @type {string} */
var MATH_ROUND_OPERATOR_ROUND: string;
/** @type {string} */
var MATH_ROUND_OPERATOR_ROUNDUP: string;
/** @type {string} */
var MATH_ROUND_OPERATOR_ROUNDDOWN: string;
/** @type {string} */
var MATH_ONLIST_HELPURL: string;
/** @type {string} */
var MATH_ONLIST_OPERATOR_SUM: string;
/** @type {string} */
var MATH_ONLIST_TOOLTIP_SUM: string;
/** @type {string} */
var MATH_ONLIST_OPERATOR_MIN: string;
/** @type {string} */
var MATH_ONLIST_TOOLTIP_MIN: string;
/** @type {string} */
var MATH_ONLIST_OPERATOR_MAX: string;
/** @type {string} */
var MATH_ONLIST_TOOLTIP_MAX: string;
/** @type {string} */
var MATH_ONLIST_OPERATOR_AVERAGE: string;
/** @type {string} */
var MATH_ONLIST_TOOLTIP_AVERAGE: string;
/** @type {string} */
var MATH_ONLIST_OPERATOR_MEDIAN: string;
/** @type {string} */
var MATH_ONLIST_TOOLTIP_MEDIAN: string;
/** @type {string} */
var MATH_ONLIST_OPERATOR_MODE: string;
/** @type {string} */
var MATH_ONLIST_TOOLTIP_MODE: string;
/** @type {string} */
var MATH_ONLIST_OPERATOR_STD_DEV: string;
/** @type {string} */
var MATH_ONLIST_TOOLTIP_STD_DEV: string;
/** @type {string} */
var MATH_ONLIST_OPERATOR_RANDOM: string;
/** @type {string} */
var MATH_ONLIST_TOOLTIP_RANDOM: string;
/** @type {string} */
var MATH_MODULO_HELPURL: string;
/** @type {string} */
var MATH_MODULO_TITLE: string;
/** @type {string} */
var MATH_MODULO_TOOLTIP: string;
/** @type {string} */
var MATH_CONSTRAIN_HELPURL: string;
/** @type {string} */
var MATH_CONSTRAIN_TITLE: string;
/** @type {string} */
var MATH_CONSTRAIN_TOOLTIP: string;
/** @type {string} */
var MATH_RANDOM_INT_HELPURL: string;
/** @type {string} */
var MATH_RANDOM_INT_TITLE: string;
/** @type {string} */
var MATH_RANDOM_INT_TOOLTIP: string;
/** @type {string} */
var MATH_RANDOM_FLOAT_HELPURL: string;
/** @type {string} */
var MATH_RANDOM_FLOAT_TITLE_RANDOM: string;
/** @type {string} */
var MATH_RANDOM_FLOAT_TOOLTIP: string;
/** @type {string} */
var MATH_ATAN2_HELPURL: string;
/** @type {string} */
var MATH_ATAN2_TITLE: string;
/** @type {string} */
var MATH_ATAN2_TOOLTIP: string;
/** @type {string} */
var TEXT_TEXT_HELPURL: string;
/** @type {string} */
var TEXT_TEXT_TOOLTIP: string;
/** @type {string} */
var TEXT_JOIN_HELPURL: string;
/** @type {string} */
var TEXT_JOIN_TITLE_CREATEWITH: string;
/** @type {string} */
var TEXT_JOIN_TOOLTIP: string;
/** @type {string} */
var TEXT_CREATE_JOIN_TITLE_JOIN: string;
/** @type {string} */
var TEXT_CREATE_JOIN_TOOLTIP: string;
/** @type {string} */
var TEXT_CREATE_JOIN_ITEM_TITLE_ITEM: string;
/** @type {string} */
var TEXT_CREATE_JOIN_ITEM_TOOLTIP: string;
/** @type {string} */
var TEXT_APPEND_HELPURL: string;
/** @type {string} */
var TEXT_APPEND_TITLE: string;
/** @type {string} */
var TEXT_APPEND_VARIABLE: string;
/** @type {string} */
var TEXT_APPEND_TOOLTIP: string;
/** @type {string} */
var TEXT_LENGTH_HELPURL: string;
/** @type {string} */
var TEXT_LENGTH_TITLE: string;
/** @type {string} */
var TEXT_LENGTH_TOOLTIP: string;
/** @type {string} */
var TEXT_ISEMPTY_HELPURL: string;
/** @type {string} */
var TEXT_ISEMPTY_TITLE: string;
/** @type {string} */
var TEXT_ISEMPTY_TOOLTIP: string;
/** @type {string} */
var TEXT_INDEXOF_HELPURL: string;
/** @type {string} */
var TEXT_INDEXOF_TOOLTIP: string;
/** @type {string} */
var TEXT_INDEXOF_TITLE: string;
/** @type {string} */
var TEXT_INDEXOF_OPERATOR_FIRST: string;
/** @type {string} */
var TEXT_INDEXOF_OPERATOR_LAST: string;
/** @type {string} */
var TEXT_CHARAT_HELPURL: string;
/** @type {string} */
var TEXT_CHARAT_TITLE: string;
/** @type {string} */
var TEXT_CHARAT_FROM_START: string;
/** @type {string} */
var TEXT_CHARAT_FROM_END: string;
/** @type {string} */
var TEXT_CHARAT_FIRST: string;
/** @type {string} */
var TEXT_CHARAT_LAST: string;
/** @type {string} */
var TEXT_CHARAT_RANDOM: string;
/** @type {string} */
var TEXT_CHARAT_TAIL: string;
/** @type {string} */
var TEXT_CHARAT_TOOLTIP: string;
/** @type {string} */
var TEXT_GET_SUBSTRING_TOOLTIP: string;
/** @type {string} */
var TEXT_GET_SUBSTRING_HELPURL: string;
/** @type {string} */
var TEXT_GET_SUBSTRING_INPUT_IN_TEXT: string;
/** @type {string} */
var TEXT_GET_SUBSTRING_START_FROM_START: string;
/** @type {string} */
var TEXT_GET_SUBSTRING_START_FROM_END: string;
/** @type {string} */
var TEXT_GET_SUBSTRING_START_FIRST: string;
/** @type {string} */
var TEXT_GET_SUBSTRING_END_FROM_START: string;
/** @type {string} */
var TEXT_GET_SUBSTRING_END_FROM_END: string;
/** @type {string} */
var TEXT_GET_SUBSTRING_END_LAST: string;
/** @type {string} */
var TEXT_GET_SUBSTRING_TAIL: string;
/** @type {string} */
var TEXT_CHANGECASE_HELPURL: string;
/** @type {string} */
var TEXT_CHANGECASE_TOOLTIP: string;
/** @type {string} */
var TEXT_CHANGECASE_OPERATOR_UPPERCASE: string;
/** @type {string} */
var TEXT_CHANGECASE_OPERATOR_LOWERCASE: string;
/** @type {string} */
var TEXT_CHANGECASE_OPERATOR_TITLECASE: string;
/** @type {string} */
var TEXT_TRIM_HELPURL: string;
/** @type {string} */
var TEXT_TRIM_TOOLTIP: string;
/** @type {string} */
var TEXT_TRIM_OPERATOR_BOTH: string;
/** @type {string} */
var TEXT_TRIM_OPERATOR_LEFT: string;
/** @type {string} */
var TEXT_TRIM_OPERATOR_RIGHT: string;
/** @type {string} */
var TEXT_PRINT_HELPURL: string;
/** @type {string} */
var TEXT_PRINT_TITLE: string;
/** @type {string} */
var TEXT_PRINT_TOOLTIP: string;
/** @type {string} */
var TEXT_PROMPT_HELPURL: string;
/** @type {string} */
var TEXT_PROMPT_TYPE_TEXT: string;
/** @type {string} */
var TEXT_PROMPT_TYPE_NUMBER: string;
/** @type {string} */
var TEXT_PROMPT_TOOLTIP_NUMBER: string;
/** @type {string} */
var TEXT_PROMPT_TOOLTIP_TEXT: string;
/** @type {string} */
var TEXT_COUNT_MESSAGE0: string;
/** @type {string} */
var TEXT_COUNT_HELPURL: string;
/** @type {string} */
var TEXT_COUNT_TOOLTIP: string;
/** @type {string} */
var TEXT_REPLACE_MESSAGE0: string;
/** @type {string} */
var TEXT_REPLACE_HELPURL: string;
/** @type {string} */
var TEXT_REPLACE_TOOLTIP: string;
/** @type {string} */
var TEXT_REVERSE_MESSAGE0: string;
/** @type {string} */
var TEXT_REVERSE_HELPURL: string;
/** @type {string} */
var TEXT_REVERSE_TOOLTIP: string;
/** @type {string} */
var LISTS_CREATE_EMPTY_HELPURL: string;
/** @type {string} */
var LISTS_CREATE_EMPTY_TITLE: string;
/** @type {string} */
var LISTS_CREATE_EMPTY_TOOLTIP: string;
/** @type {string} */
var LISTS_CREATE_WITH_HELPURL: string;
/** @type {string} */
var LISTS_CREATE_WITH_TOOLTIP: string;
/** @type {string} */
var LISTS_CREATE_WITH_INPUT_WITH: string;
/** @type {string} */
var LISTS_CREATE_WITH_CONTAINER_TITLE_ADD: string;
/** @type {string} */
var LISTS_CREATE_WITH_CONTAINER_TOOLTIP: string;
/** @type {string} */
var LISTS_CREATE_WITH_ITEM_TITLE: string;
/** @type {string} */
var LISTS_CREATE_WITH_ITEM_TOOLTIP: string;
/** @type {string} */
var LISTS_REPEAT_HELPURL: string;
/** @type {string} */
var LISTS_REPEAT_TOOLTIP: string;
/** @type {string} */
var LISTS_REPEAT_TITLE: string;
/** @type {string} */
var LISTS_LENGTH_HELPURL: string;
/** @type {string} */
var LISTS_LENGTH_TITLE: string;
/** @type {string} */
var LISTS_LENGTH_TOOLTIP: string;
/** @type {string} */
var LISTS_ISEMPTY_HELPURL: string;
/** @type {string} */
var LISTS_ISEMPTY_TITLE: string;
/** @type {string} */
var LISTS_ISEMPTY_TOOLTIP: string;
/** @type {string} */
var LISTS_INLIST: string;
/** @type {string} */
var LISTS_INDEX_OF_HELPURL: string;
/** @type {string} */
var LISTS_INDEX_OF_INPUT_IN_LIST: string;
/** @type {string} */
var LISTS_INDEX_OF_FIRST: string;
/** @type {string} */
var LISTS_INDEX_OF_LAST: string;
/** @type {string} */
var LISTS_INDEX_OF_TOOLTIP: string;
/** @type {string} */
var LISTS_GET_INDEX_HELPURL: string;
/** @type {string} */
var LISTS_GET_INDEX_GET: string;
/** @type {string} */
var LISTS_GET_INDEX_GET_REMOVE: string;
/** @type {string} */
var LISTS_GET_INDEX_REMOVE: string;
/** @type {string} */
var LISTS_GET_INDEX_FROM_START: string;
/** @type {string} */
var LISTS_GET_INDEX_FROM_END: string;
/** @type {string} */
var LISTS_GET_INDEX_FIRST: string;
/** @type {string} */
var LISTS_GET_INDEX_LAST: string;
/** @type {string} */
var LISTS_GET_INDEX_RANDOM: string;
/** @type {string} */
var LISTS_GET_INDEX_TAIL: string;
/** @type {string} */
var LISTS_GET_INDEX_INPUT_IN_LIST: string;
/** @type {string} */
var LISTS_INDEX_FROM_START_TOOLTIP: string;
/** @type {string} */
var LISTS_INDEX_FROM_END_TOOLTIP: string;
/** @type {string} */
var LISTS_GET_INDEX_TOOLTIP_GET_FROM: string;
/** @type {string} */
var LISTS_GET_INDEX_TOOLTIP_GET_FIRST: string;
/** @type {string} */
var LISTS_GET_INDEX_TOOLTIP_GET_LAST: string;
/** @type {string} */
var LISTS_GET_INDEX_TOOLTIP_GET_RANDOM: string;
/** @type {string} */
var LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FROM: string;
/** @type {string} */
var LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FIRST: string;
/** @type {string} */
var LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_LAST: string;
/** @type {string} */
var LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_RANDOM: string;
/** @type {string} */
var LISTS_GET_INDEX_TOOLTIP_REMOVE_FROM: string;
/** @type {string} */
var LISTS_GET_INDEX_TOOLTIP_REMOVE_FIRST: string;
/** @type {string} */
var LISTS_GET_INDEX_TOOLTIP_REMOVE_LAST: string;
/** @type {string} */
var LISTS_GET_INDEX_TOOLTIP_REMOVE_RANDOM: string;
/** @type {string} */
var LISTS_SET_INDEX_HELPURL: string;
/** @type {string} */
var LISTS_SET_INDEX_INPUT_IN_LIST: string;
/** @type {string} */
var LISTS_SET_INDEX_SET: string;
/** @type {string} */
var LISTS_SET_INDEX_INSERT: string;
/** @type {string} */
var LISTS_SET_INDEX_INPUT_TO: string;
/** @type {string} */
var LISTS_SET_INDEX_TOOLTIP_SET_FROM: string;
/** @type {string} */
var LISTS_SET_INDEX_TOOLTIP_SET_FIRST: string;
/** @type {string} */
var LISTS_SET_INDEX_TOOLTIP_SET_LAST: string;
/** @type {string} */
var LISTS_SET_INDEX_TOOLTIP_SET_RANDOM: string;
/** @type {string} */
var LISTS_SET_INDEX_TOOLTIP_INSERT_FROM: string;
/** @type {string} */
var LISTS_SET_INDEX_TOOLTIP_INSERT_FIRST: string;
/** @type {string} */
var LISTS_SET_INDEX_TOOLTIP_INSERT_LAST: string;
/** @type {string} */
var LISTS_SET_INDEX_TOOLTIP_INSERT_RANDOM: string;
/** @type {string} */
var LISTS_GET_SUBLIST_HELPURL: string;
/** @type {string} */
var LISTS_GET_SUBLIST_INPUT_IN_LIST: string;
/** @type {string} */
var LISTS_GET_SUBLIST_START_FROM_START: string;
/** @type {string} */
var LISTS_GET_SUBLIST_START_FROM_END: string;
/** @type {string} */
var LISTS_GET_SUBLIST_START_FIRST: string;
/** @type {string} */
var LISTS_GET_SUBLIST_END_FROM_START: string;
/** @type {string} */
var LISTS_GET_SUBLIST_END_FROM_END: string;
/** @type {string} */
var LISTS_GET_SUBLIST_END_LAST: string;
/** @type {string} */
var LISTS_GET_SUBLIST_TAIL: string;
/** @type {string} */
var LISTS_GET_SUBLIST_TOOLTIP: string;
/** @type {string} */
var LISTS_SORT_HELPURL: string;
/** @type {string} */
var LISTS_SORT_TITLE: string;
/** @type {string} */
var LISTS_SORT_TOOLTIP: string;
/** @type {string} */
var LISTS_SORT_ORDER_ASCENDING: string;
/** @type {string} */
var LISTS_SORT_ORDER_DESCENDING: string;
/** @type {string} */
var LISTS_SORT_TYPE_NUMERIC: string;
/** @type {string} */
var LISTS_SORT_TYPE_TEXT: string;
/** @type {string} */
var LISTS_SORT_TYPE_IGNORECASE: string;
/** @type {string} */
var LISTS_SPLIT_HELPURL: string;
/** @type {string} */
var LISTS_SPLIT_LIST_FROM_TEXT: string;
/** @type {string} */
var LISTS_SPLIT_TEXT_FROM_LIST: string;
/** @type {string} */
var LISTS_SPLIT_WITH_DELIMITER: string;
/** @type {string} */
var LISTS_SPLIT_TOOLTIP_SPLIT: string;
/** @type {string} */
var LISTS_SPLIT_TOOLTIP_JOIN: string;
/** @type {string} */
var LISTS_REVERSE_HELPURL: string;
/** @type {string} */
var LISTS_REVERSE_MESSAGE0: string;
/** @type {string} */
var LISTS_REVERSE_TOOLTIP: string;
/** @type {string} */
var ORDINAL_NUMBER_SUFFIX: string;
/** @type {string} */
var VARIABLES_GET_HELPURL: string;
/** @type {string} */
var VARIABLES_GET_TOOLTIP: string;
/** @type {string} */
var VARIABLES_GET_CREATE_SET: string;
/** @type {string} */
var VARIABLES_SET_HELPURL: string;
/** @type {string} */
var VARIABLES_SET: string;
/** @type {string} */
var VARIABLES_SET_TOOLTIP: string;
/** @type {string} */
var VARIABLES_SET_CREATE_GET: string;
/** @type {string} */
var PROCEDURES_DEFNORETURN_HELPURL: string;
/** @type {string} */
var PROCEDURES_DEFNORETURN_TITLE: string;
/** @type {string} */
var PROCEDURES_DEFNORETURN_PROCEDURE: string;
/** @type {string} */
var PROCEDURES_BEFORE_PARAMS: string;
/** @type {string} */
var PROCEDURES_CALL_BEFORE_PARAMS: string;
/** @type {string} */
var PROCEDURES_DEFNORETURN_DO: string;
/** @type {string} */
var PROCEDURES_DEFNORETURN_TOOLTIP: string;
/** @type {string} */
var PROCEDURES_DEFNORETURN_COMMENT: string;
/** @type {string} */
var PROCEDURES_DEFRETURN_HELPURL: string;
/** @type {string} */
var PROCEDURES_DEFRETURN_TITLE: string;
/** @type {string} */
var PROCEDURES_DEFRETURN_PROCEDURE: string;
/** @type {string} */
var PROCEDURES_DEFRETURN_DO: string;
/** @type {string} */
var PROCEDURES_DEFRETURN_COMMENT: string;
/** @type {string} */
var PROCEDURES_DEFRETURN_RETURN: string;
/** @type {string} */
var PROCEDURES_DEFRETURN_TOOLTIP: string;
/** @type {string} */
var PROCEDURES_ALLOW_STATEMENTS: string;
/** @type {string} */
var PROCEDURES_DEF_DUPLICATE_WARNING: string;
/** @type {string} */
var PROCEDURES_CALLNORETURN_HELPURL: string;
/** @type {string} */
var PROCEDURES_CALLNORETURN_TOOLTIP: string;
/** @type {string} */
var PROCEDURES_CALLRETURN_HELPURL: string;
/** @type {string} */
var PROCEDURES_CALLRETURN_TOOLTIP: string;
/** @type {string} */
var PROCEDURES_MUTATORCONTAINER_TITLE: string;
/** @type {string} */
var PROCEDURES_MUTATORCONTAINER_TOOLTIP: string;
/** @type {string} */
var PROCEDURES_MUTATORARG_TITLE: string;
/** @type {string} */
var PROCEDURES_MUTATORARG_TOOLTIP: string;
/** @type {string} */
var PROCEDURES_HIGHLIGHT_DEF: string;
/** @type {string} */
var PROCEDURES_CREATE_DO: string;
/** @type {string} */
var PROCEDURES_IFRETURN_TOOLTIP: string;
/** @type {string} */
var PROCEDURES_IFRETURN_HELPURL: string;
/** @type {string} */
var PROCEDURES_IFRETURN_WARNING: string;
/** @type {string} */
var WORKSPACE_COMMENT_DEFAULT_TEXT: string;
/** @type {string} */
var WORKSPACE_ARIA_LABEL: string;
/** @type {string} */
var COLLAPSED_WARNINGS_WARNING: string;
}
Reference in New Issue View Git Blame Copy Permalink