From 29e1f0cb034788bcffca066c7dd7e8b9193d2b92 Mon Sep 17 00:00:00 2001 From: Beka Westberg Date: Mon, 27 Jun 2022 16:25:56 +0000 Subject: [PATCH] fix: tsc errors picked up from develop (#6224) * fix: relative path for deprecation utils * fix: checking if properties exist in svg_math * fix: set all timeout PIDs to AnyDuringMigration * fix: make nullability errors explicity in block drag surface * fix: make null check in events_block_change explicit * fix: make getEventWorkspace_ internal so we can access it from CommentCreateDeleteHelper * fix: rename DIV -> containerDiv in tooltip * fix: ignore backwards compat check in category * fix: set block styles to AnyDuringMigration * fix: type typo in KeyboardShortcut * fix: constants name in row measurables * fix: typecast in mutator * fix: populateProcedures type of flattened array * fix: ignore errors related to workspace comment deserialization * chore: format files * fix: renaming imports missing file extensions * fix: remove check for sound.play * fix: temporarily remove bad requireType. All `export type` statements are stripped when tsc is run. This means that when we attempt to require BlockDefinition from the block files, we get an error because it does not exist. We decided to temporarily remove the require, because this will no longer be a problem when we conver the blocks to typescript, and everything gets compiled together. * fix: bad jsdoc in array * fix: silence missing property errors Closure was complaining about inexistant properties, but they actually do exist, they're just not being transpiled by tsc in a way that closure understands. I.E. if things are initialized in a function called by the constructor, rather than in a class field or in the custructor itself, closure would error. It would also error on enums, because they are transpiled to a weird IIFE. * fix: context menu action handler not knowing the type of this. this: TypeX information gets stripped when tsc is run, so closure could not know that this was not global. Fixed this by reorganizing to use the option object directly instead of passing it to onAction to be bound to this. * fix: readd getDeveloperVars checks (should not be part of migration) This was found because ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE was no longer being accessed. * fix: silence closure errors about overriding supertype props We propertly define the overrides in typescript, but these get removed from the compiled output, so closure doesn't know they exist. * fix: silence globalThis errors this: TypeX annotations get stripped from the compiled output, so closure can't know that we're accessing the correct things. However, typescript makes sure that this always has the correct properties, so silencing this should be fine. * fix: bad jsdoc name * chore: attempt compiling with blockly.js * fix: attempt moving the import statement above the namespace line * chore: add todo comments to block def files * chore: remove todo from context menu * chore: add comments abotu disabled errors --- blocks/blocks.js | 4 +- blocks/colour.js | 4 +- blocks/lists.js | 4 +- blocks/logic.js | 4 +- blocks/loops.js | 4 +- blocks/math.js | 4 +- blocks/procedures.js | 4 +- blocks/text.js | 4 +- blocks/variables.js | 4 +- blocks/variables_dynamic.js | 4 +- core/block.ts | 6 +- core/block_animations.ts | 2 +- core/block_drag_surface.ts | 8 +- core/block_dragger.ts | 2 +- core/block_svg.ts | 9 +- core/blockly.js | 890 ++++++++++++++++++ core/blockly.ts | 10 +- core/bubble.ts | 4 +- core/bubble_dragger.ts | 4 +- core/comment.ts | 10 +- core/connection.ts | 2 +- core/connection_db.ts | 2 +- core/contextmenu.ts | 10 +- core/dropdowndiv.ts | 2 +- core/events/events_abstract.ts | 3 +- core/events/events_block_change.ts | 2 +- core/extensions.ts | 2 +- core/field.ts | 6 +- core/field_checkbox.ts | 2 +- core/field_colour.ts | 2 +- core/field_textinput.ts | 2 +- core/field_variable.ts | 2 +- core/flyout_button.ts | 2 +- core/flyout_vertical.ts | 4 +- core/gesture.ts | 4 +- core/inject.ts | 2 - core/input.ts | 2 +- .../i_ast_node_location_with_block.ts | 2 +- core/interfaces/i_block_dragger.ts | 4 +- core/interfaces/i_bounded_element.ts | 2 +- core/interfaces/i_bubble.ts | 4 +- core/interfaces/i_collapsible_toolbox_item.ts | 2 +- core/interfaces/i_connection_checker.ts | 4 +- core/interfaces/i_delete_area.ts | 2 +- core/interfaces/i_drag_target.ts | 4 +- core/interfaces/i_flyout.ts | 8 +- core/interfaces/i_keyboard_accessible.ts | 2 +- core/interfaces/i_metrics_manager.ts | 6 +- core/interfaces/i_positionable.ts | 4 +- core/interfaces/i_selectable_toolbox_item.ts | 2 +- core/interfaces/i_toolbox.ts | 8 +- core/mutator.ts | 6 +- core/names.ts | 9 +- core/positionable_helpers.ts | 2 +- core/procedures.ts | 2 +- core/renderers/common/i_path_object.ts | 6 +- core/renderers/common/marker_svg.ts | 2 +- core/renderers/common/path_object.ts | 2 +- core/renderers/geras/highlighter.ts | 2 +- core/renderers/geras/path_object.ts | 2 +- core/renderers/geras/renderer.ts | 2 +- core/renderers/measurables/row.ts | 2 +- core/renderers/measurables/spacer_row.ts | 2 +- core/renderers/zelos/path_object.ts | 2 +- core/renderers/zelos/renderer.ts | 2 +- core/shortcut_registry.ts | 2 +- core/theme/classic.ts | 3 +- core/toolbox/category.ts | 3 +- core/toolbox/toolbox.ts | 4 +- core/tooltip.ts | 10 +- core/touch.ts | 2 +- core/trashcan.ts | 6 +- core/utils/object.ts | 2 +- core/utils/string.ts | 2 +- core/utils/svg_math.ts | 4 +- core/utils/toolbox.ts | 4 +- core/variable_map.ts | 4 +- core/variable_model.ts | 2 +- core/variables.ts | 12 + core/warning.ts | 2 +- core/workspace.ts | 2 +- core/workspace_audio.ts | 2 +- core/workspace_comment.ts | 6 +- core/workspace_comment_svg.ts | 6 +- core/workspace_svg.ts | 25 +- core/xml.ts | 8 +- core/zoom_controls.ts | 4 +- scripts/gulpfiles/build_tasks.js | 6 +- scripts/gulpfiles/chunks.json | 335 ++++--- tsconfig.json | 3 + 90 files changed, 1262 insertions(+), 330 deletions(-) create mode 100644 core/blockly.js diff --git a/blocks/blocks.js b/blocks/blocks.js index f6758c2c5..70ef47832 100644 --- a/blocks/blocks.js +++ b/blocks/blocks.js @@ -22,8 +22,10 @@ const procedures = goog.require('Blockly.libraryBlocks.procedures'); const texts = goog.require('Blockly.libraryBlocks.texts'); const variables = goog.require('Blockly.libraryBlocks.variables'); const variablesDynamic = goog.require('Blockly.libraryBlocks.variablesDynamic'); +// const {BlockDefinition} = goog.requireType('Blockly.blocks'); +// TODO (6248): Properly import the BlockDefinition type. /* eslint-disable-next-line no-unused-vars */ -const {BlockDefinition} = goog.requireType('Blockly.blocks'); +const BlockDefinition = Object; exports.colour = colour; diff --git a/blocks/colour.js b/blocks/colour.js index 91b82a282..236b97c5c 100644 --- a/blocks/colour.js +++ b/blocks/colour.js @@ -11,8 +11,10 @@ goog.module('Blockly.libraryBlocks.colour'); +// const {BlockDefinition} = goog.requireType('Blockly.blocks'); +// TODO (6248): Properly import the BlockDefinition type. /* eslint-disable-next-line no-unused-vars */ -const {BlockDefinition} = goog.requireType('Blockly.blocks'); +const BlockDefinition = Object; const {createBlockDefinitionsFromJsonArray, defineBlocks} = goog.require('Blockly.common'); /** @suppress {extraRequire} */ goog.require('Blockly.FieldColour'); diff --git a/blocks/lists.js b/blocks/lists.js index 4bfd6fae3..5acd7925f 100644 --- a/blocks/lists.js +++ b/blocks/lists.js @@ -17,8 +17,10 @@ const Xml = goog.require('Blockly.Xml'); const {Align} = goog.require('Blockly.Input'); /* eslint-disable-next-line no-unused-vars */ const {Block} = goog.requireType('Blockly.Block'); +// const {BlockDefinition} = goog.requireType('Blockly.blocks'); +// TODO (6248): Properly import the BlockDefinition type. /* eslint-disable-next-line no-unused-vars */ -const {BlockDefinition} = goog.requireType('Blockly.blocks'); +const BlockDefinition = Object; const {ConnectionType} = goog.require('Blockly.ConnectionType'); const {FieldDropdown} = goog.require('Blockly.FieldDropdown'); const {Msg} = goog.require('Blockly.Msg'); diff --git a/blocks/logic.js b/blocks/logic.js index 9c3ae781e..ee1228d98 100644 --- a/blocks/logic.js +++ b/blocks/logic.js @@ -19,8 +19,10 @@ const Extensions = goog.require('Blockly.Extensions'); const xmlUtils = goog.require('Blockly.utils.xml'); /* eslint-disable-next-line no-unused-vars */ const {Block} = goog.requireType('Blockly.Block'); +// const {BlockDefinition} = goog.requireType('Blockly.blocks'); +// TODO (6248): Properly import the BlockDefinition type. /* eslint-disable-next-line no-unused-vars */ -const {BlockDefinition} = goog.requireType('Blockly.blocks'); +const BlockDefinition = Object; const {Msg} = goog.require('Blockly.Msg'); const {Mutator} = goog.require('Blockly.Mutator'); /* eslint-disable-next-line no-unused-vars */ diff --git a/blocks/loops.js b/blocks/loops.js index 82b831be3..220c17d67 100644 --- a/blocks/loops.js +++ b/blocks/loops.js @@ -21,8 +21,10 @@ const Variables = goog.require('Blockly.Variables'); const xmlUtils = goog.require('Blockly.utils.xml'); /* eslint-disable-next-line no-unused-vars */ const {Block} = goog.requireType('Blockly.Block'); +// const {BlockDefinition} = goog.requireType('Blockly.blocks'); +// TODO (6248): Properly import the BlockDefinition type. /* eslint-disable-next-line no-unused-vars */ -const {BlockDefinition} = goog.requireType('Blockly.blocks'); +const BlockDefinition = Object; const {Msg} = goog.require('Blockly.Msg'); const {createBlockDefinitionsFromJsonArray, defineBlocks} = goog.require('Blockly.common'); /** @suppress {extraRequire} */ diff --git a/blocks/math.js b/blocks/math.js index bd5458fdd..b6ade7f89 100644 --- a/blocks/math.js +++ b/blocks/math.js @@ -19,8 +19,10 @@ const FieldDropdown = goog.require('Blockly.FieldDropdown'); const xmlUtils = goog.require('Blockly.utils.xml'); /* eslint-disable-next-line no-unused-vars */ const {Block} = goog.requireType('Blockly.Block'); +// const {BlockDefinition} = goog.requireType('Blockly.blocks'); +// TODO (6248): Properly import the BlockDefinition type. /* eslint-disable-next-line no-unused-vars */ -const {BlockDefinition} = goog.requireType('Blockly.blocks'); +const BlockDefinition = Object; const {createBlockDefinitionsFromJsonArray, defineBlocks} = goog.require('Blockly.common'); /** @suppress {extraRequire} */ goog.require('Blockly.FieldLabel'); diff --git a/blocks/procedures.js b/blocks/procedures.js index 21afdb7fa..011c63228 100644 --- a/blocks/procedures.js +++ b/blocks/procedures.js @@ -23,8 +23,10 @@ const xmlUtils = goog.require('Blockly.utils.xml'); const {Align} = goog.require('Blockly.Input'); /* eslint-disable-next-line no-unused-vars */ const {Block} = goog.requireType('Blockly.Block'); +// const {BlockDefinition} = goog.requireType('Blockly.blocks'); +// TODO (6248): Properly import the BlockDefinition type. /* eslint-disable-next-line no-unused-vars */ -const {BlockDefinition} = goog.requireType('Blockly.blocks'); +const BlockDefinition = Object; const {config} = goog.require('Blockly.config'); /* eslint-disable-next-line no-unused-vars */ const {FieldCheckbox} = goog.require('Blockly.FieldCheckbox'); diff --git a/blocks/text.js b/blocks/text.js index 5c3c28110..786fb432b 100644 --- a/blocks/text.js +++ b/blocks/text.js @@ -19,8 +19,10 @@ const xmlUtils = goog.require('Blockly.utils.xml'); const {Align} = goog.require('Blockly.Input'); /* eslint-disable-next-line no-unused-vars */ const {Block} = goog.requireType('Blockly.Block'); +// const {BlockDefinition} = goog.requireType('Blockly.blocks'); +// TODO (6248): Properly import the BlockDefinition type. /* eslint-disable-next-line no-unused-vars */ -const {BlockDefinition} = goog.requireType('Blockly.blocks'); +const BlockDefinition = Object; const {ConnectionType} = goog.require('Blockly.ConnectionType'); const {FieldDropdown} = goog.require('Blockly.FieldDropdown'); const {FieldImage} = goog.require('Blockly.FieldImage'); diff --git a/blocks/variables.js b/blocks/variables.js index 56a7b5eb8..a3bbd1a8d 100644 --- a/blocks/variables.js +++ b/blocks/variables.js @@ -18,8 +18,10 @@ const Variables = goog.require('Blockly.Variables'); const xmlUtils = goog.require('Blockly.utils.xml'); /* eslint-disable-next-line no-unused-vars */ const {Block} = goog.requireType('Blockly.Block'); +// const {BlockDefinition} = goog.requireType('Blockly.blocks'); +// TODO (6248): Properly import the BlockDefinition type. /* eslint-disable-next-line no-unused-vars */ -const {BlockDefinition} = goog.requireType('Blockly.blocks'); +const BlockDefinition = Object; const {Msg} = goog.require('Blockly.Msg'); const {createBlockDefinitionsFromJsonArray, defineBlocks} = goog.require('Blockly.common'); /** @suppress {extraRequire} */ diff --git a/blocks/variables_dynamic.js b/blocks/variables_dynamic.js index 6020c7859..4ee7dcadc 100644 --- a/blocks/variables_dynamic.js +++ b/blocks/variables_dynamic.js @@ -20,8 +20,10 @@ const Variables = goog.require('Blockly.Variables'); const xml = goog.require('Blockly.utils.xml'); /* eslint-disable-next-line no-unused-vars */ const {Block} = goog.requireType('Blockly.Block'); +// const {BlockDefinition} = goog.requireType('Blockly.blocks'); +// TODO (6248): Properly import the BlockDefinition type. /* eslint-disable-next-line no-unused-vars */ -const {BlockDefinition} = goog.requireType('Blockly.blocks'); +const BlockDefinition = Object; const {Msg} = goog.require('Blockly.Msg'); const {createBlockDefinitionsFromJsonArray, defineBlocks} = goog.require('Blockly.common'); /** @suppress {extraRequire} */ diff --git a/core/block.ts b/core/block.ts index 38a607810..a136d6cd9 100644 --- a/core/block.ts +++ b/core/block.ts @@ -16,11 +16,11 @@ import * as goog from '../closure/goog/goog.js'; goog.declareModuleId('Blockly.Block'); // Unused import preserved for side-effects. Remove if unneeded. -import './events/events_block_change'; +import './events/events_block_change.js'; // Unused import preserved for side-effects. Remove if unneeded. -import './events/events_block_create'; +import './events/events_block_create.js'; // Unused import preserved for side-effects. Remove if unneeded. -import './events/events_block_delete'; +import './events/events_block_delete.js'; import {Blocks} from './blocks.js'; /* eslint-disable-next-line no-unused-vars */ diff --git a/core/block_animations.ts b/core/block_animations.ts index 8201f38fd..7caa93e0f 100644 --- a/core/block_animations.ts +++ b/core/block_animations.ts @@ -30,7 +30,7 @@ interface CloneRect { } // eslint-disable-line no-unused-vars /** PID of disconnect UI animation. There can only be one at a time. */ -let disconnectPid = 0; +let disconnectPid: AnyDuringMigration = 0; /** SVG group of wobbling block. There can only be one at a time. */ // AnyDuringMigration because: Type 'null' is not assignable to type 'Element'. diff --git a/core/block_drag_surface.ts b/core/block_drag_surface.ts index 34376c9d0..cca671a6f 100644 --- a/core/block_drag_surface.ts +++ b/core/block_drag_surface.ts @@ -122,7 +122,7 @@ export class BlockDragSurfaceSvg { const roundY = Math.round(y); this.childSurfaceXY_.x = roundX; this.childSurfaceXY_.y = roundY; - this.dragGroup_.setAttribute( + this.dragGroup_!.setAttribute( 'transform', 'translate(' + roundX + ',' + roundY + ') scale(' + scale + ')'); } @@ -132,12 +132,12 @@ export class BlockDragSurfaceSvg { * @private */ translateSurfaceInternal_() { - let x = this.surfaceXY_.x; - let y = this.surfaceXY_.y; + let x = this.surfaceXY_!.x; + let y = this.surfaceXY_!.y; // Make sure the svg exists on a pixel boundary so that it is not fuzzy. x = Math.round(x); y = Math.round(y); - this.SVG_.style.display = 'block'; + this.SVG_!.style.display = 'block'; // AnyDuringMigration because: Argument of type 'SVGElement | null' is not // assignable to parameter of type 'Element'. diff --git a/core/block_dragger.ts b/core/block_dragger.ts index 1ae394695..6b9ac897f 100644 --- a/core/block_dragger.ts +++ b/core/block_dragger.ts @@ -16,7 +16,7 @@ import * as goog from '../closure/goog/goog.js'; goog.declareModuleId('Blockly.BlockDragger'); // Unused import preserved for side-effects. Remove if unneeded. -import './events/events_block_drag'; +import './events/events_block_drag.js'; import * as blockAnimation from './block_animations.js'; /* eslint-disable-next-line no-unused-vars */ diff --git a/core/block_svg.ts b/core/block_svg.ts index c5e67c0e3..c79850da3 100644 --- a/core/block_svg.ts +++ b/core/block_svg.ts @@ -17,11 +17,11 @@ goog.declareModuleId('Blockly.BlockSvg'); /* eslint-disable-next-line no-unused-vars */ // Unused import preserved for side-effects. Remove if unneeded. -import './theme'; +import './theme.js'; // Unused import preserved for side-effects. Remove if unneeded. -import './events/events_selected'; +import './events/events_selected.js'; // Unused import preserved for side-effects. Remove if unneeded. -import './touch'; +import './touch.js'; import {Block} from './block.js'; import * as blockAnimations from './block_animations.js'; @@ -131,7 +131,8 @@ export class BlockSvg extends Block implements IASTNodeLocationSvg, */ // AnyDuringMigration because: Type 'null' is not assignable to type '{ [key: // string]: number; }'. - private warningTextDb_: {[key: string]: number} = null as AnyDuringMigration; + private warningTextDb_: {[key: string]: AnyDuringMigration} = + null as AnyDuringMigration; /** Block's mutator icon (if any). */ mutator: Mutator|null = null; diff --git a/core/blockly.js b/core/blockly.js new file mode 100644 index 000000000..96878e606 --- /dev/null +++ b/core/blockly.js @@ -0,0 +1,890 @@ +/** + * @license + * Copyright 2011 Google LLC + * SPDX-License-Identifier: Apache-2.0 + */ + +/** + * @fileoverview The top level namespace used to access the Blockly library. + * @suppress {moduleImport} + */ +'use strict'; + +/** + * The top level namespace used to access the Blockly library. + * @namespace Blockly + */ +goog.module('Blockly'); +goog.module.declareLegacyNamespace(); + +const ContextMenu = goog.require('Blockly.ContextMenu'); +const ContextMenuItems = goog.require('Blockly.ContextMenuItems'); +const Css = goog.require('Blockly.Css'); +const Events = goog.require('Blockly.Events'); +const Extensions = goog.require('Blockly.Extensions'); +const Procedures = goog.require('Blockly.Procedures'); +const ShortcutItems = goog.require('Blockly.ShortcutItems'); +const Themes = goog.require('Blockly.Themes'); +const Tooltip = goog.require('Blockly.Tooltip'); +const Touch = goog.require('Blockly.Touch'); +const Variables = goog.require('Blockly.Variables'); +const VariablesDynamic = goog.require('Blockly.VariablesDynamic'); +const WidgetDiv = goog.require('Blockly.WidgetDiv'); +const Xml = goog.require('Blockly.Xml'); +const blockAnimations = goog.require('Blockly.blockAnimations'); +const blockRendering = goog.require('Blockly.blockRendering'); +const browserEvents = goog.require('Blockly.browserEvents'); +const bumpObjects = goog.require('Blockly.bumpObjects'); +const clipboard = goog.require('Blockly.clipboard'); +const colour = goog.require('Blockly.utils.colour'); +const common = goog.require('Blockly.common'); +const constants = goog.require('Blockly.constants'); +const deprecation = goog.require('Blockly.utils.deprecation'); +const dialog = goog.require('Blockly.dialog'); +const dropDownDiv = goog.require('Blockly.dropDownDiv'); +const fieldRegistry = goog.require('Blockly.fieldRegistry'); +const geras = goog.require('Blockly.geras'); +const internalConstants = goog.require('Blockly.internalConstants'); +const minimalist = goog.require('Blockly.minimalist'); +const registry = goog.require('Blockly.registry'); +const serializationBlocks = goog.require('Blockly.serialization.blocks'); +const serializationExceptions = goog.require('Blockly.serialization.exceptions'); +const serializationPriorities = goog.require('Blockly.serialization.priorities'); +const serializationRegistry = goog.require('Blockly.serialization.registry'); +const serializationVariables = goog.require('Blockly.serialization.variables'); +const serializationWorkspaces = goog.require('Blockly.serialization.workspaces'); +const svgMath = goog.require('Blockly.utils.svgMath'); +const thrasos = goog.require('Blockly.thrasos'); +const toolbox = goog.require('Blockly.utils.toolbox'); +const uiPosition = goog.require('Blockly.uiPosition'); +const utils = goog.require('Blockly.utils'); +const zelos = goog.require('Blockly.zelos'); +const {Align, Input} = goog.require('Blockly.Input'); +const {ASTNode} = goog.require('Blockly.ASTNode'); +const {BasicCursor} = goog.require('Blockly.BasicCursor'); +const {BlockDragSurfaceSvg} = goog.require('Blockly.BlockDragSurfaceSvg'); +const {BlockDragger} = goog.require('Blockly.BlockDragger'); +const {BlockSvg} = goog.require('Blockly.BlockSvg'); +const {BlocklyOptions} = goog.require('Blockly.BlocklyOptions'); +const {Blocks} = goog.require('Blockly.blocks'); +const {Block} = goog.require('Blockly.Block'); +const {BubbleDragger} = goog.require('Blockly.BubbleDragger'); +const {Bubble} = goog.require('Blockly.Bubble'); +const {CollapsibleToolboxCategory} = goog.require('Blockly.CollapsibleToolboxCategory'); +const {Comment} = goog.require('Blockly.Comment'); +const {ComponentManager} = goog.require('Blockly.ComponentManager'); +const {config} = goog.require('Blockly.config'); +const {ConnectionChecker} = goog.require('Blockly.ConnectionChecker'); +const {ConnectionDB} = goog.require('Blockly.ConnectionDB'); +const {ConnectionType} = goog.require('Blockly.ConnectionType'); +const {Connection} = goog.require('Blockly.Connection'); +const {ContextMenuRegistry} = goog.require('Blockly.ContextMenuRegistry'); +const {Cursor} = goog.require('Blockly.Cursor'); +const {DeleteArea} = goog.require('Blockly.DeleteArea'); +const {DragTarget} = goog.require('Blockly.DragTarget'); +const {FieldAngle} = goog.require('Blockly.FieldAngle'); +const {FieldCheckbox} = goog.require('Blockly.FieldCheckbox'); +const {FieldColour} = goog.require('Blockly.FieldColour'); +const {FieldDropdown} = goog.require('Blockly.FieldDropdown'); +const {FieldImage} = goog.require('Blockly.FieldImage'); +const {FieldLabelSerializable} = goog.require('Blockly.FieldLabelSerializable'); +const {FieldLabel} = goog.require('Blockly.FieldLabel'); +const {FieldMultilineInput} = goog.require('Blockly.FieldMultilineInput'); +const {FieldNumber} = goog.require('Blockly.FieldNumber'); +const {FieldTextInput} = goog.require('Blockly.FieldTextInput'); +const {FieldVariable} = goog.require('Blockly.FieldVariable'); +const {Field} = goog.require('Blockly.Field'); +const {FlyoutButton} = goog.require('Blockly.FlyoutButton'); +const {FlyoutMetricsManager} = goog.require('Blockly.FlyoutMetricsManager'); +const {Flyout} = goog.require('Blockly.Flyout'); +const {Generator} = goog.require('Blockly.Generator'); +const {Gesture} = goog.require('Blockly.Gesture'); +const {Grid} = goog.require('Blockly.Grid'); +const {HorizontalFlyout} = goog.require('Blockly.HorizontalFlyout'); +const {IASTNodeLocationSvg} = goog.require('Blockly.IASTNodeLocationSvg'); +const {IASTNodeLocationWithBlock} = goog.require('Blockly.IASTNodeLocationWithBlock'); +const {IASTNodeLocation} = goog.require('Blockly.IASTNodeLocation'); +const {IAutoHideable} = goog.require('Blockly.IAutoHideable'); +const {IBlockDragger} = goog.require('Blockly.IBlockDragger'); +const {IBoundedElement} = goog.require('Blockly.IBoundedElement'); +const {IBubble} = goog.require('Blockly.IBubble'); +const {ICollapsibleToolboxItem} = goog.require('Blockly.ICollapsibleToolboxItem'); +const {IComponent} = goog.require('Blockly.IComponent'); +const {IConnectionChecker} = goog.require('Blockly.IConnectionChecker'); +const {IContextMenu} = goog.require('Blockly.IContextMenu'); +const {ICopyable} = goog.require('Blockly.ICopyable'); +const {IDeletable} = goog.require('Blockly.IDeletable'); +const {IDeleteArea} = goog.require('Blockly.IDeleteArea'); +const {IDragTarget} = goog.require('Blockly.IDragTarget'); +const {IDraggable} = goog.require('Blockly.IDraggable'); +const {IFlyout} = goog.require('Blockly.IFlyout'); +const {IKeyboardAccessible} = goog.require('Blockly.IKeyboardAccessible'); +const {IMetricsManager} = goog.require('Blockly.IMetricsManager'); +const {IMovable} = goog.require('Blockly.IMovable'); +const {IPositionable} = goog.require('Blockly.IPositionable'); +const {IRegistrableField} = goog.require('Blockly.IRegistrableField'); +const {IRegistrable} = goog.require('Blockly.IRegistrable'); +const {ISelectableToolboxItem} = goog.require('Blockly.ISelectableToolboxItem'); +const {ISelectable} = goog.require('Blockly.ISelectable'); +const {ISerializer} = goog.require('Blockly.serialization.ISerializer'); +const {IStyleable} = goog.require('Blockly.IStyleable'); +const {IToolboxItem} = goog.require('Blockly.IToolboxItem'); +const {IToolbox} = goog.require('Blockly.IToolbox'); +const {Icon} = goog.require('Blockly.Icon'); +const {InsertionMarkerManager} = goog.require('Blockly.InsertionMarkerManager'); +const {Marker} = goog.require('Blockly.Marker'); +const {MarkerManager} = goog.require('Blockly.MarkerManager'); +const {MenuItem} = goog.require('Blockly.MenuItem'); +const {Menu} = goog.require('Blockly.Menu'); +const {MetricsManager} = goog.require('Blockly.MetricsManager'); +const {Mutator} = goog.require('Blockly.Mutator'); +const {Msg} = goog.require('Blockly.Msg'); +const {Names} = goog.require('Blockly.Names'); +const {Options} = goog.require('Blockly.Options'); +const {RenderedConnection} = goog.require('Blockly.RenderedConnection'); +const {ScrollbarPair} = goog.require('Blockly.ScrollbarPair'); +const {Scrollbar} = goog.require('Blockly.Scrollbar'); +const {ShortcutRegistry} = goog.require('Blockly.ShortcutRegistry'); +const {TabNavigateCursor} = goog.require('Blockly.TabNavigateCursor'); +const {ThemeManager} = goog.require('Blockly.ThemeManager'); +const {Theme} = goog.require('Blockly.Theme'); +const {ToolboxCategory} = goog.require('Blockly.ToolboxCategory'); +const {ToolboxItem} = goog.require('Blockly.ToolboxItem'); +const {ToolboxSeparator} = goog.require('Blockly.ToolboxSeparator'); +const {Toolbox} = goog.require('Blockly.Toolbox'); +const {TouchGesture} = goog.require('Blockly.TouchGesture'); +const {Trashcan} = goog.require('Blockly.Trashcan'); +const {VariableMap} = goog.require('Blockly.VariableMap'); +const {VariableModel} = goog.require('Blockly.VariableModel'); +const {VerticalFlyout} = goog.require('Blockly.VerticalFlyout'); +const {Warning} = goog.require('Blockly.Warning'); +const {WorkspaceAudio} = goog.require('Blockly.WorkspaceAudio'); +const {WorkspaceCommentSvg} = goog.require('Blockly.WorkspaceCommentSvg'); +const {WorkspaceComment} = goog.require('Blockly.WorkspaceComment'); +const {WorkspaceDragSurfaceSvg} = goog.require('Blockly.WorkspaceDragSurfaceSvg'); +const {WorkspaceDragger} = goog.require('Blockly.WorkspaceDragger'); +const {WorkspaceSvg, resizeSvgContents} = goog.require('Blockly.WorkspaceSvg'); +const {Workspace} = goog.require('Blockly.Workspace'); +const {ZoomControls} = goog.require('Blockly.ZoomControls'); +const {inject} = goog.require('Blockly.inject'); +const {inputTypes} = goog.require('Blockly.inputTypes'); +/** @suppress {extraRequire} */ +goog.require('Blockly.Events.BlockCreate'); +/** @suppress {extraRequire} */ +goog.require('Blockly.Events.FinishedLoading'); +/** @suppress {extraRequire} */ +goog.require('Blockly.Events.Ui'); +/** @suppress {extraRequire} */ +goog.require('Blockly.Events.UiBase'); +/** @suppress {extraRequire} */ +goog.require('Blockly.Events.VarCreate'); + + +/** + * 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} + * @alias Blockly.VERSION + */ +exports.VERSION = 'uncompiled'; + +/* + * Top-level functions and properties on the Blockly namespace. + * These are used only in external code. Do not reference these + * from internal code as importing from this file can cause circular + * dependencies. Do not add new functions here. There is probably a better + * namespace to put new functions on. + */ + +/* + * Aliases for input alignments used in block defintions. + */ + +/** + * @see Blockly.Input.Align.LEFT + * @alias Blockly.ALIGN_LEFT + */ +exports.ALIGN_LEFT = Align.LEFT; + +/** + * @see Blockly.Input.Align.CENTRE + * @alias Blockly.ALIGN_CENTRE + */ +exports.ALIGN_CENTRE = Align.CENTRE; + +/** + * @see Blockly.Input.Align.RIGHT + * @alias Blockly.ALIGN_RIGHT + */ +exports.ALIGN_RIGHT = Align.RIGHT; + +/* + * Aliases for constants used for connection and input types. + */ + +/** + * @see ConnectionType.INPUT_VALUE + * @alias Blockly.INPUT_VALUE + */ +exports.INPUT_VALUE = ConnectionType.INPUT_VALUE; + +/** + * @see ConnectionType.OUTPUT_VALUE + * @alias Blockly.OUTPUT_VALUE + */ +exports.OUTPUT_VALUE = ConnectionType.OUTPUT_VALUE; + +/** + * @see ConnectionType.NEXT_STATEMENT + * @alias Blockly.NEXT_STATEMENT + */ +exports.NEXT_STATEMENT = ConnectionType.NEXT_STATEMENT; + +/** + * @see ConnectionType.PREVIOUS_STATEMENT + * @alias Blockly.PREVIOUS_STATEMENT + */ +exports.PREVIOUS_STATEMENT = ConnectionType.PREVIOUS_STATEMENT; + +/** + * @see inputTypes.DUMMY_INPUT + * @alias Blockly.DUMMY_INPUT + */ +exports.DUMMY_INPUT = inputTypes.DUMMY; + +/** + * Aliases for toolbox positions. + */ + +/** + * @see toolbox.Position.TOP + * @alias Blockly.TOOLBOX_AT_TOP + */ +exports.TOOLBOX_AT_TOP = toolbox.Position.TOP; + +/** + * @see toolbox.Position.BOTTOM + * @alias Blockly.TOOLBOX_AT_BOTTOM + */ +exports.TOOLBOX_AT_BOTTOM = toolbox.Position.BOTTOM; + +/** + * @see toolbox.Position.LEFT + * @alias Blockly.TOOLBOX_AT_LEFT + */ +exports.TOOLBOX_AT_LEFT = toolbox.Position.LEFT; + +/** + * @see toolbox.Position.RIGHT + * @alias Blockly.TOOLBOX_AT_RIGHT + */ +exports.TOOLBOX_AT_RIGHT = toolbox.Position.RIGHT; + +/* + * Other aliased functions. + */ + +/** + * 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 workspace.resizeContents 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 {!WorkspaceSvg} workspace Any workspace in the SVG. + * @see Blockly.common.svgResize + * @alias Blockly.svgResize + */ +exports.svgResize = common.svgResize; + +/** + * Close tooltips, context menus, dropdown selections, etc. + * @param {boolean=} opt_onlyClosePopups Whether only popups should be closed. + * @see Blockly.WorkspaceSvg.hideChaff + * @alias Blockly.hideChaff + */ +const hideChaff = function(opt_onlyClosePopups) { + /** @type {!WorkspaceSvg} */ (common.getMainWorkspace()) + .hideChaff(opt_onlyClosePopups); +}; +exports.hideChaff = hideChaff; + +/** + * 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 {!Workspace} The main workspace. + * @see Blockly.common.getMainWorkspace + * @alias Blockly.getMainWorkspace + */ +exports.getMainWorkspace = common.getMainWorkspace; + +/** + * Define blocks from an array of JSON block definitions, as might be generated + * by the Blockly Developer Tools. + * @param {!Array} jsonArray An array of JSON block definitions. + * @see Blockly.common.defineBlocksWithJsonArray + * @alias Blockly.defineBlocksWithJsonArray + */ +exports.defineBlocksWithJsonArray = common.defineBlocksWithJsonArray; + +/** + * 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. + * @see Blockly.common.setParentContainer + * @alias Blockly.setParentContainer + */ +exports.setParentContainer = common.setParentContainer; + +/* + * Aliased functions and properties that used to be on the Blockly namespace. + * Everything in this section is deprecated. Both external and internal code + * should avoid using these functions and use the designated replacements. + * Anything in this section may be removed in a future version of Blockly. + */ + +// Add accessors for properties on Blockly that have now been deprecated. +Object.defineProperties(exports, { + /** + * Wrapper to window.alert() that app developers may override to + * provide alternatives to the modal browser window. + * @name Blockly.alert + * @type {!function(string, function()=)} + * @deprecated Use Blockly.dialog.alert / .setAlert() instead. + * (December 2021) + * @suppress {checkTypes} + */ + alert: { + set: function(newAlert) { + deprecation.warn('Blockly.alert', 'December 2021', 'December 2022'); + dialog.setAlert(newAlert); + }, + get: function() { + deprecation.warn( + 'Blockly.alert', 'December 2021', 'December 2022', + 'Blockly.dialog.alert()'); + return dialog.alert; + }, + }, + /** + * Wrapper to window.confirm() that app developers may override to + * provide alternatives to the modal browser window. + * @name Blockly.confirm + * @type {!function(string, function()=)} + * @deprecated Use Blockly.dialog.confirm / .setConfirm() instead. + * (December 2021) + * @suppress {checkTypes} + */ + confirm: { + set: function(newConfirm) { + deprecation.warn('Blockly.confirm', 'December 2021', 'December 2022'); + dialog.setConfirm(newConfirm); + }, + get: function() { + deprecation.warn( + 'Blockly.confirm', 'December 2021', 'December 2022', + 'Blockly.dialog.confirm()'); + return dialog.confirm; + }, + }, + /** + * The main workspace most recently used. + * Set by Blockly.WorkspaceSvg.prototype.markFocused + * @name Blockly.mainWorkspace + * @type {Workspace} + * @suppress {checkTypes} + */ + mainWorkspace: { + set: function(x) { + common.setMainWorkspace(x); + }, + get: function() { + return common.getMainWorkspace(); + }, + }, + /** + * Wrapper to window.prompt() that app developers may override to + * provide alternatives to the modal browser window. Built-in + * browser prompts are often used for better text input experience + * on mobile device. We strongly recommend testing mobile when + * overriding this. + * @name Blockly.prompt + * @type {!function(string, string, function()=)} + * @deprecated Use Blockly.dialog.prompt / .setPrompt() instead. + * (December 2021) + * @suppress {checkTypes} + */ + prompt: { + set: function(newPrompt) { + deprecation.warn('Blockly.prompt', 'December 2021', 'December 2022'); + dialog.setPrompt(newPrompt); + }, + get: function() { + deprecation.warn( + 'Blockly.prompt', 'December 2021', 'December 2022', + 'Blockly.dialog.prompt()'); + return dialog.prompt; + }, + }, + /** + * Currently selected block. + * @name Blockly.selected + * @type {?ICopyable} + * @suppress {checkTypes} + */ + selected: { + get: function() { + return common.getSelected(); + }, + set: function(newSelection) { + common.setSelected(newSelection); + }, + }, + /** + * The richness of block colours, regardless of the hue. + * Must be in the range of 0 (inclusive) to 1 (exclusive). + * @name Blockly.HSV_SATURATION + * @type {number} + * @suppress {checkTypes} + */ + HSV_SATURATION: { + get: function() { + return utils.colour.getHsvSaturation(); + }, + set: function(newValue) { + utils.colour.setHsvSaturation(newValue); + }, + }, + /** + * The intensity of block colours, regardless of the hue. + * Must be in the range of 0 (inclusive) to 1 (exclusive). + * @name Blockly.HSV_VALUE + * @type {number} + * @suppress {checkTypes} + */ + HSV_VALUE: { + get: function() { + return utils.colour.getHsvValue(); + }, + set: function(newValue) { + utils.colour.setHsvValue(newValue); + }, + }, +}); + +/** + * Returns the dimensions of the specified SVG image. + * @param {!SVGElement} svg SVG image. + * @return {!Size} Contains width and height properties. + * @deprecated Use workspace.setCachedParentSvgSize. (2021 March 5) + * @see Blockly.WorkspaceSvg.setCachedParentSvgSize + * @alias Blockly.svgSize + */ +exports.svgSize = svgMath.svgSize; + +/** + * Size the workspace when the contents change. This also updates + * scrollbars accordingly. + * @param {!WorkspaceSvg} workspace The workspace to resize. + * @deprecated Use workspace.resizeContents. (2021 December) + * @see Blockly.WorkspaceSvg.resizeContents + * @alias Blockly.resizeSvgContents + */ +const resizeSvgContentsLocal = function(workspace) { + deprecation.warn( + 'Blockly.resizeSvgContents', 'December 2021', 'December 2022', + 'Blockly.WorkspaceSvg.resizeSvgContents'); + resizeSvgContents(workspace); +}; +exports.resizeSvgContents = resizeSvgContentsLocal; + +/** + * Copy a block or workspace comment onto the local clipboard. + * @param {!ICopyable} toCopy Block or Workspace Comment to be copied. + * @deprecated Use Blockly.clipboard.copy(). (2021 December) + * @see Blockly.clipboard.copy + * @alias Blockly.copy + */ +const copy = function(toCopy) { + deprecation.warn( + 'Blockly.copy', 'December 2021', 'December 2022', + 'Blockly.clipboard.copy'); + clipboard.copy(toCopy); +}; +exports.copy = copy; + +/** + * Paste a block or workspace comment on to the main workspace. + * @return {boolean} True if the paste was successful, false otherwise. + * @deprecated Use Blockly.clipboard.paste(). (2021 December) + * @see Blockly.clipboard.paste + * @alias Blockly.paste + */ +const paste = function() { + deprecation.warn( + 'Blockly.paste', 'December 2021', 'December 2022', + 'Blockly.clipboard.paste'); + return !!clipboard.paste(); +}; +exports.paste = paste; + +/** + * Duplicate this block and its children, or a workspace comment. + * @param {!ICopyable} toDuplicate Block or Workspace Comment to be + * copied. + * @deprecated Use Blockly.clipboard.duplicate(). (2021 December) + * @see Blockly.clipboard.duplicate + * @alias Blockly.duplicate + */ +const duplicate = function(toDuplicate) { + deprecation.warn( + 'Blockly.duplicate', 'December 2021', 'December 2022', + 'Blockly.clipboard.duplicate'); + clipboard.duplicate(toDuplicate); +}; +exports.duplicate = duplicate; + +/** + * Is the given string a number (includes negative and decimals). + * @param {string} str Input string. + * @return {boolean} True if number, false otherwise. + * @deprecated Use Blockly.utils.string.isNumber(str). (2021 December) + * @see Blockly.utils.string.isNumber + * @alias Blockly.isNumber + */ +const isNumber = function(str) { + deprecation.warn( + 'Blockly.isNumber', 'December 2021', 'December 2022', + 'Blockly.utils.string.isNumber'); + return utils.string.isNumber(str); +}; +exports.isNumber = isNumber; + +/** + * 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'. + * @deprecated Use Blockly.utils.colour.hueToHex(). (2021 December) + * @see Blockly.utils.colour.hueToHex + * @alias Blockly.hueToHex + */ +const hueToHex = function(hue) { + deprecation.warn( + 'Blockly.hueToHex', 'December 2021', 'December 2022', + 'Blockly.utils.colour.hueToHex'); + return colour.hueToHex(hue); +}; +exports.hueToHex = hueToHex; + +/** + * 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 {!browserEvents.Data} Opaque data that can be passed to + * unbindEvent_. + * @deprecated Use Blockly.browserEvents.bind(). (December 2021) + * @see Blockly.browserEvents.bind + * @alias Blockly.bindEvent_ + */ +const bindEvent_ = function(node, name, thisObject, func) { + deprecation.warn( + 'Blockly.bindEvent_', 'December 2021', 'December 2022', + 'Blockly.browserEvents.bind'); + return browserEvents.bind(node, name, thisObject, func); +}; +exports.bindEvent_ = bindEvent_; + +/** + * Unbind one or more events event from a function call. + * @param {!browserEvents.Data} bindData Opaque data from bindEvent_. + * This list is emptied during the course of calling this function. + * @return {!Function} The function call. + * @deprecated Use Blockly.browserEvents.unbind(). (December 2021) + * @see browserEvents.unbind + * @alias Blockly.unbindEvent_ + */ +const unbindEvent_ = function(bindData) { + deprecation.warn( + 'Blockly.unbindEvent_', 'December 2021', 'December 2022', + 'Blockly.browserEvents.unbind'); + return browserEvents.unbind(bindData); +}; +exports.unbindEvent_ = unbindEvent_; + +/** + * 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 {!browserEvents.Data} Opaque data that can be passed to + * unbindEvent_. + * @deprecated Use Blockly.browserEvents.conditionalBind(). (December 2021) + * @see browserEvents.conditionalBind + * @alias Blockly.bindEventWithChecks_ + */ +const bindEventWithChecks_ = function( + node, name, thisObject, func, opt_noCaptureIdentifier, + opt_noPreventDefault) { + deprecation.warn( + 'Blockly.bindEventWithChecks_', 'December 2021', 'December 2022', + 'Blockly.browserEvents.conditionalBind'); + return browserEvents.conditionalBind( + node, name, thisObject, func, opt_noCaptureIdentifier, + opt_noPreventDefault); +}; +exports.bindEventWithChecks_ = bindEventWithChecks_; + +// Aliases to allow external code to access these values for legacy reasons. +exports.COLLAPSE_CHARS = internalConstants.COLLAPSE_CHARS; +exports.DRAG_STACK = internalConstants.DRAG_STACK; +exports.OPPOSITE_TYPE = internalConstants.OPPOSITE_TYPE; +exports.RENAME_VARIABLE_ID = internalConstants.RENAME_VARIABLE_ID; +exports.DELETE_VARIABLE_ID = internalConstants.DELETE_VARIABLE_ID; +exports.COLLAPSED_INPUT_NAME = constants.COLLAPSED_INPUT_NAME; +exports.COLLAPSED_FIELD_NAME = constants.COLLAPSED_FIELD_NAME; + +/** + * 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} + * @alias Blockly.VARIABLE_CATEGORY_NAME + */ +exports.VARIABLE_CATEGORY_NAME = Variables.CATEGORY_NAME; + +/** + * 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} + * @alias Blockly.VARIABLE_DYNAMIC_CATEGORY_NAME + */ +exports.VARIABLE_DYNAMIC_CATEGORY_NAME = VariablesDynamic.CATEGORY_NAME; +/** + * 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} + * @alias Blockly.PROCEDURE_CATEGORY_NAME + */ +exports.PROCEDURE_CATEGORY_NAME = Procedures.CATEGORY_NAME; + +// Re-export submodules that no longer declareLegacyNamespace. +exports.ASTNode = ASTNode; +exports.BasicCursor = BasicCursor; +exports.Block = Block; +exports.BlocklyOptions = BlocklyOptions; +exports.BlockDragger = BlockDragger; +exports.BlockDragSurfaceSvg = BlockDragSurfaceSvg; +exports.BlockSvg = BlockSvg; +exports.Blocks = Blocks; +exports.Bubble = Bubble; +exports.BubbleDragger = BubbleDragger; +exports.CollapsibleToolboxCategory = CollapsibleToolboxCategory; +exports.Comment = Comment; +exports.ComponentManager = ComponentManager; +exports.Connection = Connection; +exports.ConnectionType = ConnectionType; +exports.ConnectionChecker = ConnectionChecker; +exports.ConnectionDB = ConnectionDB; +exports.ContextMenu = ContextMenu; +exports.ContextMenuItems = ContextMenuItems; +exports.ContextMenuRegistry = ContextMenuRegistry; +exports.Css = Css; +exports.Cursor = Cursor; +exports.DeleteArea = DeleteArea; +exports.DragTarget = DragTarget; +exports.DropDownDiv = dropDownDiv; +exports.Events = Events; +exports.Extensions = Extensions; +exports.Field = Field; +exports.FieldAngle = FieldAngle; +exports.FieldCheckbox = FieldCheckbox; +exports.FieldColour = FieldColour; +exports.FieldDropdown = FieldDropdown; +exports.FieldImage = FieldImage; +exports.FieldLabel = FieldLabel; +exports.FieldLabelSerializable = FieldLabelSerializable; +exports.FieldMultilineInput = FieldMultilineInput; +exports.FieldNumber = FieldNumber; +exports.FieldTextInput = FieldTextInput; +exports.FieldVariable = FieldVariable; +exports.Flyout = Flyout; +exports.FlyoutButton = FlyoutButton; +exports.FlyoutMetricsManager = FlyoutMetricsManager; +exports.Generator = Generator; +exports.Gesture = Gesture; +exports.Grid = Grid; +exports.HorizontalFlyout = HorizontalFlyout; +exports.IASTNodeLocation = IASTNodeLocation; +exports.IASTNodeLocationSvg = IASTNodeLocationSvg; +exports.IASTNodeLocationWithBlock = IASTNodeLocationWithBlock; +exports.IAutoHideable = IAutoHideable; +exports.IBlockDragger = IBlockDragger; +exports.IBoundedElement = IBoundedElement; +exports.IBubble = IBubble; +exports.ICollapsibleToolboxItem = ICollapsibleToolboxItem; +exports.IComponent = IComponent; +exports.IConnectionChecker = IConnectionChecker; +exports.IContextMenu = IContextMenu; +exports.Icon = Icon; +exports.ICopyable = ICopyable; +exports.IDeletable = IDeletable; +exports.IDeleteArea = IDeleteArea; +exports.IDragTarget = IDragTarget; +exports.IDraggable = IDraggable; +exports.IFlyout = IFlyout; +exports.IKeyboardAccessible = IKeyboardAccessible; +exports.IMetricsManager = IMetricsManager; +exports.IMovable = IMovable; +exports.Input = Input; +exports.InsertionMarkerManager = InsertionMarkerManager; +exports.IPositionable = IPositionable; +exports.IRegistrable = IRegistrable; +exports.IRegistrableField = IRegistrableField; +exports.ISelectable = ISelectable; +exports.ISelectableToolboxItem = ISelectableToolboxItem; +exports.IStyleable = IStyleable; +exports.IToolbox = IToolbox; +exports.IToolboxItem = IToolboxItem; +exports.Marker = Marker; +exports.MarkerManager = MarkerManager; +exports.Menu = Menu; +exports.MenuItem = MenuItem; +exports.MetricsManager = MetricsManager; +exports.Mutator = Mutator; +exports.Msg = Msg; +exports.Names = Names; +exports.Options = Options; +exports.Procedures = Procedures; +exports.RenderedConnection = RenderedConnection; +exports.Scrollbar = Scrollbar; +exports.ScrollbarPair = ScrollbarPair; +exports.ShortcutItems = ShortcutItems; +exports.ShortcutRegistry = ShortcutRegistry; +exports.TabNavigateCursor = TabNavigateCursor; +exports.Theme = Theme; +exports.Themes = Themes; +exports.ThemeManager = ThemeManager; +exports.Toolbox = Toolbox; +exports.ToolboxCategory = ToolboxCategory; +exports.ToolboxItem = ToolboxItem; +exports.ToolboxSeparator = ToolboxSeparator; +exports.Tooltip = Tooltip; +exports.Touch = Touch; +exports.TouchGesture = TouchGesture; +exports.Trashcan = Trashcan; +exports.VariableMap = VariableMap; +exports.VariableModel = VariableModel; +exports.Variables = Variables; +exports.VariablesDynamic = VariablesDynamic; +exports.VerticalFlyout = VerticalFlyout; +exports.Warning = Warning; +exports.WidgetDiv = WidgetDiv; +exports.Workspace = Workspace; +exports.WorkspaceAudio = WorkspaceAudio; +exports.WorkspaceComment = WorkspaceComment; +exports.WorkspaceCommentSvg = WorkspaceCommentSvg; +exports.WorkspaceDragSurfaceSvg = WorkspaceDragSurfaceSvg; +exports.WorkspaceDragger = WorkspaceDragger; +exports.WorkspaceSvg = WorkspaceSvg; +exports.Xml = Xml; +exports.ZoomControls = ZoomControls; +exports.blockAnimations = blockAnimations; +exports.blockRendering = blockRendering; +exports.browserEvents = browserEvents; +exports.bumpObjects = bumpObjects; +exports.clipboard = clipboard; +exports.common = common; +exports.config = config; +/** @deprecated Use Blockly.ConnectionType instead. */ +exports.connectionTypes = ConnectionType; +exports.constants = constants; +exports.dialog = dialog; +exports.fieldRegistry = fieldRegistry; +exports.geras = geras; +exports.inject = inject; +exports.inputTypes = inputTypes; +exports.minimalist = minimalist; +exports.registry = registry; +exports.serialization = { + blocks: serializationBlocks, + exceptions: serializationExceptions, + priorities: serializationPriorities, + registry: serializationRegistry, + variables: serializationVariables, + workspaces: serializationWorkspaces, + ISerializer: ISerializer, +}; +exports.thrasos = thrasos; +exports.uiPosition = uiPosition; +exports.utils = utils; +exports.zelos = zelos; + +// If Blockly is compiled with ADVANCED_COMPILATION and/or loaded as a +// CJS or ES module there will not be a Blockly global variable +// created. This can cause problems because a very common way of +// loading translations is to use a