CodingPirates/blockly
1
0
Fork 0
mirror of https://github.com/google/blockly.git synced 2026-01-07 09:00:11 +01:00
Code Issues Packages Projects Releases Wiki Activity

chore: Migrate core/ to Typescript, actually (#6299)

Browse Source 
* fix: convert files to typescript

* fix: add alias for AnyDuringMigration so that tsc will run

* chore: format

* chore: enable ts for the clang-format workflow (#6233)

* chore: Restore @fileoverview comment locations (#6237)

* chore: add declareModuleId (#6238)

* fix: Revert comment change to app_controller.js (#6241)

* fix: Add missing import goog statements (#6240)

I've added the import statement immediately before the
goog.declareModuleId calls that depend on it.

There is an argument to be made that we should put the import
statement in their normal place amongst any other imports, and
move the declareModuleId statement to below the double blank
line below the imports, but as these are so tightly coupled,
replace the previous goog.module calls, and will both be deleted
at the same time once the transition to TypeScript is fully complete
I think it's fine (and certainly much easier) to do it this way.

* chore: Fix whitespace (#6243)

* fix: Remove spurious blank lines

  Remove extraneous blank lines introduced by deletion of
  'use strict'; pragmas.

  Also fix the location of the goog.declareModuleId call in
  core/utils/array.ts.

* fix: Add missing double-blank-line before body of modules

  Our convention is to have two blank lines between the imports (or
  module ID, if there are no imports) and the beginning of the body
  of the module.  Enforce this.

* fix: one addition format error for PR #6243

* fix(build): Skip npm prepare when running in CI (#6244)

Have npm prepare do nothing when running in CI.

We don't need to do any building, because npm test will build
everything needed in the workflows in which it is run, and we
don't want to build anything in other workflows because a tsc
error would prevent those workflows from completing.

* fix: re-add `@package` annotations as `@internal` annotations (#6232)

* fix: add ~70% of internal attributes

* fix: work on manually adding more @internal annotations

* fix: add more manual internal annotations

* fix: rename package typos to internal

* fix: final manual fixes for internal annotations

* chore: format

* chore: make unnecessary multiline jsdoc a single line

* fix: fix internal tags in serialization exceptions

* 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

* chore: move comments back to their correct positions (#6249)

* fix: work on fixing comments

* chore: finish moving all comments

* chore: format

* chore: move some other messed up comments

* chore: format

* fix: Correct enum formatting, use merged `namespace`s for types that are class static members (#6246)

* fix: formatting of enum KeyCodes

* fix: Use merged namespace for ContextMenuRegistry static types

  - Create a namespace to be merged with the ContextMenuRegistry
    class containing the types that were formerly declared as static
    properties on that class.

  - Use type aliases to export them individually as well, for
    compatibility with the changes made by MigranTS (and/or
    @gonfunko) to how other modules in core/ now import these
    types.

  - Update renamings.json5 to reflect the availability of the
    direct exports for modules that import this module directly
    (though they are not available to, and will not be used by,
    code that imports only via blockly.js/blockly.ts.)

* fix: Use merged namespace for Input.Align

  - Create a merged namespace for the Input.Align enum.

  - Use type/const aliases to export it as Input too.

  - Update renamings.json5 to reflect the availability of the
    direct export.

* fix: Use merged namespace for Names.NameType

  - Create a merged namespace for the Names.NameType enum.

  - Use type/const aliases to export it as NameType too.

  - Update renamings.json5 to reflect the availability of the
    direct export.  (This ought to have happened in an earlier
    version as it was already available by both routes.)

* chore: Fix minor issues for PR #6246

  - Use `Align` instead of `Input.Align` where possible.

* fix(build): Suppress irrelevant JSC_UNUSED_LOCAL_ASSIGNMENT errors

  tsc generates code for merged namespaces that looks like:

      (function (ClassName) {
          let EnumName;
          (function (EnumName) {
              EnumName[EnumNameAlign["v1"] = 0] = "v1";
              // etc.
          })(EnumName = ClassName.EnumName || (ClassName.EnumName = {}));
      })(ClassName || (ClassName = {}));

  and Closure Compiler complains about the fact that the EnumName let
  binding is initialised but never used.  (It exists so that any other
  code that was in the namespace could see the enum.)

  Suppress this message, since it is not actionable and lint and/or tsc
  should tell us if we have actual unused variables in our .ts files.

* chore(build): Suppress spurious warnings from closure-make-deps (#6253)

A little bit of an ugly hack, but it works: pipe stderr through
grep -v to suppress error output starting with "WARNING in".

* fix: remaining enums that weren't properly exported (#6251)

* fix: remaining enums that weren't properly exported

* chore: format

* fix: add enum value exports

* chore: format

* fix: properly export interfaces that were typedefs (#6250)

* fix: properly export interfaces that were typedefs

* fix: allowCollsion -> allowCollision

* fix: convert unconverted enums

* fix: enums that were/are instance properties

* fix: revert changes to property enums

* fix: renamed protected parameter properties (#6252)

* fix: bad protected parameter properties

* chore:format

* fix: gesture constructor

* fix: overridden properties that were renamed

* refactor: Migrate `blockly.js` to TypeScript (#6261)

* chore: Apply changes to blockly.js to blockly.ts

* fix: Build using core/blockly.ts instead of .js

  Compiles and runs in compressed mode correctly!

* fix(build): Don't depend on execSync running bash (#6262)

For some reason on Github CI servers execSync uses /bin/sh, which
is (on Ubuntu) dash rather than bash, and does not understand
the pipefail option.

So remove the grep pipe on stderr and just discard all error output
at all.

This is not ideal as errors in test deps will go unreported AND
not even cause test failure, but it's not clear that it's worth
investing more time to fix this at the moment.

* chore: use `import type` where possible (#6279)

* chore: automatically change imports to import types

* chore: revert changes that actually need to be imports

* chore: format

* chore: add more import type statements based on importsNotUsedAsValues

* chore: fix tsconfig

* chore: add link to compiler issue

* fix: add type information to blockly options (#6283)

* fix: add type information to blockly options

* chore: format

* chore: remove erroneous comment

* fix: bugs revealed by getting the built output working (#6282)

* fix: types of compose and decompose in block

* fix: workspace naming in toolbox

* chore: add jsdoc

* chore: restore registry comments to better positions

* chore: pr comments'

* fix(variables): Revert inadvertent change to allDeveloperVariables (#6290)

It appears that a function call got modified incorrectly (probably
in an effort to fix a typing issue).  This fix trivially reverts
the line in question to match the original JS version from develop.

This causes the generator tests to pass.

* fix: circular dependencies (#6281)

* chore: fix circular dependencies w/ static workspace funcs

* remove preserved imports that aren't currently necessary (probably)

* fix circular dependency with workspaces and block using stub

* fix dependency between variables and xml by moving function to utils

* add stub for trashcan as well

* fix line endings from rebase

* fix goog/base order

* add trashcan patch

* fix: types of compose and decompose in block

* fix: workspace naming in toolbox

* chore: add jsdoc

* chore: restore registry comments to better positions

* chore: remove implementations in goog.js

* chore: fix types of stubs

* chore: remove added AnyDuringMigration casts

* chore: remove modifications to xml and variables

* chore: format

* chore: remove event requirements in workspace comments

* chore: fix circular dependency with xml and workspace comments

* fixup remove ContextMenu import

* chore: fix dependency between mutator and workspace

* chore: break circular dependency between names and procedures

* chore: get tests to run?

* chore: pr comments'

* chore: fix stubbing field registry fromJson

* chore: fix spying on fire

* chore: fix stubbing parts of connection checker

* chore: fix stubbing dialog

* chore: fix stubbing style

* chore: fix spying on duplicate

* chore: fix stubbing variables

* chore: fix stubbing copy

* chore: fix stubbing in workspace

* chore: remove unnecessary stubs

* chore: fix formatting

* chore: fix other formatting

* chore: add backwards compatible static properties to workspace

* chore: move static type properties

* chore: move and comment stubs

* chore: add newlines at EOF

* chore: improve errors for monkey patched functions

* chore: update comment with a pointer to the doc

* chore: update comment with a pointer to the doc

* chore: format

* chore: revert changes to playground used for testing (#6292)

* chore: get mocha tests to pass. (#6291)

* chore: fix undo and empty code blocks

* chore: skip IE test

* chore: fix gesture test

* chore: fix replace message references test

* chore: fix string table interpolation

* chore: skip getById tests

* chore: fix field tests

* chore: fix console errors by making workspace nullable

* chore: format

* chore: fix definition overwrite warning

* chore: update metadata

* chore: temporarily modify the the advanced compile test

* chore: fix gestures by fixing test instead

Co-authored-by: Neil Fraser <fraser@google.com>
Co-authored-by: Christopher Allen <cpcallen+git@google.com>
This commit is contained in:
Beka Westberg
2022-08-02 17:30:13 +00:00
committed by GitHub
parent 27d6760ec6
commit 21d90696d1
297 changed files with 23497 additions and 27333 deletions
Download Patch File Download Diff File Expand all files Collapse all files

603
core/workspace.ts
View File

@@ -7,182 +7,131 @@
/**
* @fileoverview Object representing a workspace.
*/
'use strict';
/**
* Object representing a workspace.
* @class
*/
goog.module('Blockly.Workspace');
import * as goog from '../closure/goog/goog.js';
goog.declareModuleId('Blockly.Workspace');
const arrayUtils = goog.require('Blockly.utils.array');
const eventUtils = goog.require('Blockly.Events.utils');
const idGenerator = goog.require('Blockly.utils.idGenerator');
const math = goog.require('Blockly.utils.math');
const registry = goog.require('Blockly.registry');
/* eslint-disable-next-line no-unused-vars */
const toolbox = goog.requireType('Blockly.utils.toolbox');
/* eslint-disable-next-line no-unused-vars */
const {Abstract} = goog.requireType('Blockly.Events.Abstract');
/* eslint-disable-next-line no-unused-vars */
const {BlocklyOptions} = goog.requireType('Blockly.BlocklyOptions');
/* eslint-disable-next-line no-unused-vars */
const {Block} = goog.requireType('Blockly.Block');
/* eslint-disable-next-line no-unused-vars */
const {ConnectionDB} = goog.requireType('Blockly.ConnectionDB');
/* eslint-disable-next-line no-unused-vars */
const {IASTNodeLocation} = goog.require('Blockly.IASTNodeLocation');
/* eslint-disable-next-line no-unused-vars */
const {IConnectionChecker} = goog.requireType('Blockly.IConnectionChecker');
const {Options} = goog.require('Blockly.Options');
const {VariableMap} = goog.require('Blockly.VariableMap');
/* eslint-disable-next-line no-unused-vars */
const {VariableModel} = goog.requireType('Blockly.VariableModel');
/* eslint-disable-next-line no-unused-vars */
const {WorkspaceComment} = goog.requireType('Blockly.WorkspaceComment');
/** @suppress {extraRequire} */
goog.require('Blockly.ConnectionChecker');
// Unused import preserved for side-effects. Remove if unneeded.
import './connection_checker.js';
import type {Block} from './block.js';
import type {BlocklyOptions} from './blockly_options.js';
import type {ConnectionDB} from './connection_db.js';
import type {Abstract} from './events/events_abstract.js';
import * as common from './common.js';
import * as eventUtils from './events/utils.js';
import type {IASTNodeLocation} from './interfaces/i_ast_node_location.js';
import type {IConnectionChecker} from './interfaces/i_connection_checker.js';
import {Options} from './options.js';
import * as registry from './registry.js';
import * as arrayUtils from './utils/array.js';
import * as idGenerator from './utils/idgenerator.js';
import * as math from './utils/math.js';
import type * as toolbox from './utils/toolbox.js';
import {VariableMap} from './variable_map.js';
import type {VariableModel} from './variable_model.js';
import type {WorkspaceComment} from './workspace_comment.js';
/**
* Database of all workspaces.
* @private
*/
const WorkspaceDB_ = Object.create(null);
/**
* Class for a workspace. This is a data structure that contains blocks.
* There is no UI, and can be created headlessly.
* @implements {IASTNodeLocation}
* @alias Blockly.Workspace
*/
class Workspace {
export class Workspace implements IASTNodeLocation {
/**
* @param {!Options=} opt_options Dictionary of options.
* 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
*/
constructor(opt_options) {
/** @type {string} */
static SCAN_ANGLE = 3;
id: string;
options: Options;
RTL: boolean;
horizontalLayout: boolean;
toolboxPosition: toolbox.Position;
/**
* Returns `true` if the workspace is visible and `false` if it's headless.
*/
rendered = false;
/** Is this workspace the surface for a flyout? */
isFlyout = false;
/**
* Is this workspace the surface for a mutator?
* @internal
*/
isMutator = false;
/**
* Returns `true` if the workspace is currently in the process of a bulk
* clear.
* @internal
*/
isClearing = false;
/**
* Maximum number of undo events in stack. `0` turns off undo, `Infinity`
* sets it to unlimited.
*/
MAX_UNDO = 1024;
/** Set of databases for rapid lookup of connection locations. */
connectionDBList: ConnectionDB[] = [];
connectionChecker: IConnectionChecker;
private readonly topBlocks_: Block[] = [];
private readonly topComments_: WorkspaceComment[] = [];
private readonly commentDB_: AnyDuringMigration;
private readonly listeners_: Function[] = [];
protected undoStack_: Abstract[] = [];
protected redoStack_: Abstract[] = [];
private readonly blockDB_: AnyDuringMigration;
private readonly typedBlocksDB_: AnyDuringMigration;
private variableMap_: VariableMap;
/**
* Blocks in the flyout can refer to variables that don't exist in the main
* workspace. For instance, the "get item in list" block refers to an
* "item" variable regardless of whether the variable has been created yet.
* A FieldVariable must always refer to a VariableModel. We reconcile
* these by tracking "potential" variables in the flyout. These variables
* become real when references to them are dragged into the main workspace.
*/
private potentialVariableMap_: VariableMap|null = null;
/** @param opt_options Dictionary of options. */
constructor(opt_options?: Options) {
this.id = idGenerator.genUid();
WorkspaceDB_[this.id] = this;
/** @type {!Options} */
this.options =
opt_options || new Options(/** @type {!BlocklyOptions} */ ({}));
/** @type {boolean} */
common.registerWorkspace(this);
this.options = opt_options || new Options(({} as BlocklyOptions));
this.RTL = !!this.options.RTL;
/** @type {boolean} */
this.horizontalLayout = !!this.options.horizontalLayout;
/** @type {toolbox.Position} */
this.toolboxPosition = this.options.toolboxPosition;
/**
* Returns `true` if the workspace is visible and `false` if it's headless.
* @type {boolean}
*/
this.rendered = false;
/**
* Is this workspace the surface for a flyout?
* @type {boolean}
*/
this.isFlyout = false;
/**
* Is this workspace the surface for a mutator?
* @type {boolean}
* @package
*/
this.isMutator = false;
/**
* Returns `true` if the workspace is currently in the process of a bulk
* clear.
* @type {boolean}
* @package
*/
this.isClearing = false;
/**
* Maximum number of undo events in stack. `0` turns off undo, `Infinity`
* sets it to unlimited.
* @type {number}
*/
this.MAX_UNDO = 1024;
/**
* Set of databases for rapid lookup of connection locations.
* @type {Array<!ConnectionDB>}
*/
this.connectionDBList = null;
const connectionCheckerClass = registry.getClassFromOptions(
registry.Type.CONNECTION_CHECKER, this.options, true);
/**
* An object that encapsulates logic for safety, type, and dragging checks.
* @type {!IConnectionChecker}
*/
this.connectionChecker = new connectionCheckerClass(this);
/**
* @type {!Array<!Block>}
* @private
*/
this.topBlocks_ = [];
/**
* @type {!Array<!WorkspaceComment>}
* @private
*/
this.topComments_ = [];
/**
* @type {!Object}
* @private
*/
this.connectionChecker = new connectionCheckerClass!(this);
this.commentDB_ = Object.create(null);
/**
* @type {!Array<!Function>}
* @private
*/
this.listeners_ = [];
/**
* @type {!Array<!Abstract>}
* @protected
*/
this.undoStack_ = [];
/**
* @type {!Array<!Abstract>}
* @protected
*/
this.redoStack_ = [];
/**
* @type {!Object}
* @private
*/
this.blockDB_ = Object.create(null);
/**
* @type {!Object}
* @private
*/
this.typedBlocksDB_ = Object.create(null);
/**
* A map from variable type to list of variable names. The lists contain
* all of the named variables in the workspace, including variables that are
* not currently in use.
* @type {!VariableMap}
* @private
*/
this.variableMap_ = new VariableMap(this);
/**
* Blocks in the flyout can refer to variables that don't exist in the main
* workspace. For instance, the "get item in list" block refers to an
* "item" variable regardless of whether the variable has been created yet.
* A FieldVariable must always refer to a VariableModel. We reconcile
* these by tracking "potential" variables in the flyout. These variables
* become real when references to them are dragged into the main workspace.
* @type {?VariableMap}
* @private
*/
this.potentialVariableMap_ = null;
}
/**
@@ -194,40 +143,50 @@ class Workspace {
this.listeners_.length = 0;
this.clear();
// Remove from workspace database.
delete WorkspaceDB_[this.id];
common.unregisterWorkpace(this);
}
/**
* Compare function for sorting objects (blocks, comments, etc) by position;
* top to bottom (with slight LTR or RTL bias).
* @param {!Block | !WorkspaceComment} a The first object to
* compare.
* @param {!Block | !WorkspaceComment} b The second object to
* compare.
* @return {number} The comparison value. This tells Array.sort() how to
* change object a's index.
* @private
* @param a The first object to compare.
* @param b The second object to compare.
* @return The comparison value. This tells Array.sort() how to change object
* a's index.
*/
sortObjects_(a, b) {
const aXY = a.getRelativeToSurfaceXY();
const bXY = b.getRelativeToSurfaceXY();
return (aXY.y + Workspace.prototype.sortObjects_.offset * aXY.x) -
(bXY.y + Workspace.prototype.sortObjects_.offset * bXY.x);
private sortObjects_(a: Block|WorkspaceComment, b: Block|WorkspaceComment):
number {
// AnyDuringMigration because: Property 'getRelativeToSurfaceXY' does not
// exist on type 'Block | WorkspaceComment'.
const aXY = (a as AnyDuringMigration).getRelativeToSurfaceXY();
// AnyDuringMigration because: Property 'getRelativeToSurfaceXY' does not
// exist on type 'Block | WorkspaceComment'.
const bXY = (b as AnyDuringMigration).getRelativeToSurfaceXY();
// AnyDuringMigration because: Property 'offset' does not exist on type
// '(a: Block | WorkspaceComment, b: Block | WorkspaceComment) => number'.
// AnyDuringMigration because: Property 'offset' does not exist on type
// '(a: Block | WorkspaceComment, b: Block | WorkspaceComment) => number'.
return aXY.y +
(Workspace.prototype.sortObjects_ as AnyDuringMigration).offset *
aXY.x -
(bXY.y +
(Workspace.prototype.sortObjects_ as AnyDuringMigration).offset *
bXY.x);
}
/**
* Adds a block to the list of top blocks.
* @param {!Block} block Block to add.
* @param block Block to add.
*/
addTopBlock(block) {
addTopBlock(block: Block) {
this.topBlocks_.push(block);
}
/**
* Removes a block from the list of top blocks.
* @param {!Block} block Block to remove.
* @param block Block to remove.
*/
removeTopBlock(block) {
removeTopBlock(block: Block) {
if (!arrayUtils.removeElem(this.topBlocks_, block)) {
throw Error('Block not present in workspace\'s list of top-most blocks.');
}
@@ -236,16 +195,22 @@ class Workspace {
/**
* 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<!Block>} The top-level block objects.
* @param ordered Sort the list if true.
* @return The top-level block objects.
*/
getTopBlocks(ordered) {
getTopBlocks(ordered: boolean): Block[] {
// Copy the topBlocks_ list.
const blocks = [].concat(this.topBlocks_);
const blocks = (new Array<Block>()).concat(this.topBlocks_);
if (ordered && blocks.length > 1) {
this.sortObjects_.offset = Math.sin(math.toRadians(Workspace.SCAN_ANGLE));
// AnyDuringMigration because: Property 'offset' does not exist on type
// '(a: Block | WorkspaceComment, b: Block | WorkspaceComment) => number'.
(this.sortObjects_ as AnyDuringMigration).offset =
Math.sin(math.toRadians(Workspace.SCAN_ANGLE));
if (this.RTL) {
this.sortObjects_.offset *= -1;
// AnyDuringMigration because: Property 'offset' does not exist on type
// '(a: Block | WorkspaceComment, b: Block | WorkspaceComment) =>
// number'.
(this.sortObjects_ as AnyDuringMigration).offset *= -1;
}
blocks.sort(this.sortObjects_);
}
@@ -254,9 +219,9 @@ class Workspace {
/**
* Add a block to the list of blocks keyed by type.
* @param {!Block} block Block to add.
* @param block Block to add.
*/
addTypedBlock(block) {
addTypedBlock(block: Block) {
if (!this.typedBlocksDB_[block.type]) {
this.typedBlocksDB_[block.type] = [];
}
@@ -265,9 +230,9 @@ class Workspace {
/**
* Remove a block from the list of blocks keyed by type.
* @param {!Block} block Block to remove.
* @param block Block to remove.
*/
removeTypedBlock(block) {
removeTypedBlock(block: Block) {
arrayUtils.removeElem(this.typedBlocksDB_[block.type], block);
if (!this.typedBlocksDB_[block.type].length) {
delete this.typedBlocksDB_[block.type];
@@ -277,34 +242,40 @@ class Workspace {
/**
* 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<!Block>} The blocks of the given type.
* @param type The type of block to search for.
* @param ordered Sort the list if true.
* @return The blocks of the given type.
*/
getBlocksByType(type, ordered) {
getBlocksByType(type: string, ordered: boolean): Block[] {
if (!this.typedBlocksDB_[type]) {
return [];
}
const blocks = this.typedBlocksDB_[type].slice(0);
if (ordered && blocks.length > 1) {
this.sortObjects_.offset = Math.sin(math.toRadians(Workspace.SCAN_ANGLE));
// AnyDuringMigration because: Property 'offset' does not exist on type
// '(a: Block | WorkspaceComment, b: Block | WorkspaceComment) => number'.
(this.sortObjects_ as AnyDuringMigration).offset =
Math.sin(math.toRadians(Workspace.SCAN_ANGLE));
if (this.RTL) {
this.sortObjects_.offset *= -1;
// AnyDuringMigration because: Property 'offset' does not exist on type
// '(a: Block | WorkspaceComment, b: Block | WorkspaceComment) =>
// number'.
(this.sortObjects_ as AnyDuringMigration).offset *= -1;
}
blocks.sort(this.sortObjects_);
}
return blocks.filter(function(block) {
return blocks.filter(function(block: AnyDuringMigration) {
return !block.isInsertionMarker();
});
}
/**
* Adds a comment to the list of top comments.
* @param {!WorkspaceComment} comment comment to add.
* @package
* @param comment comment to add.
* @internal
*/
addTopComment(comment) {
addTopComment(comment: WorkspaceComment) {
this.topComments_.push(comment);
// Note: If the comment database starts to hold block comments, this may
@@ -319,10 +290,10 @@ class Workspace {
/**
* Removes a comment from the list of top comments.
* @param {!WorkspaceComment} comment comment to remove.
* @package
* @param comment comment to remove.
* @internal
*/
removeTopComment(comment) {
removeTopComment(comment: WorkspaceComment) {
if (!arrayUtils.removeElem(this.topComments_, comment)) {
throw Error(
'Comment not present in workspace\'s list of top-most ' +
@@ -336,17 +307,23 @@ class Workspace {
/**
* 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<!WorkspaceComment>} The top-level comment objects.
* @package
* @param ordered Sort the list if true.
* @return The top-level comment objects.
* @internal
*/
getTopComments(ordered) {
getTopComments(ordered: boolean): WorkspaceComment[] {
// Copy the topComments_ list.
const comments = [].concat(this.topComments_);
const comments = (new Array<WorkspaceComment>()).concat(this.topComments_);
if (ordered && comments.length > 1) {
this.sortObjects_.offset = Math.sin(math.toRadians(Workspace.SCAN_ANGLE));
// AnyDuringMigration because: Property 'offset' does not exist on type
// '(a: Block | WorkspaceComment, b: Block | WorkspaceComment) => number'.
(this.sortObjects_ as AnyDuringMigration).offset =
Math.sin(math.toRadians(Workspace.SCAN_ANGLE));
if (this.RTL) {
this.sortObjects_.offset *= -1;
// AnyDuringMigration because: Property 'offset' does not exist on type
// '(a: Block | WorkspaceComment, b: Block | WorkspaceComment) =>
// number'.
(this.sortObjects_ as AnyDuringMigration).offset *= -1;
}
comments.sort(this.sortObjects_);
}
@@ -356,11 +333,11 @@ class Workspace {
/**
* 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<!Block>} Array of blocks.
* @param ordered Sort the list if true.
* @return Array of blocks.
*/
getAllBlocks(ordered) {
let blocks;
getAllBlocks(ordered: boolean): Block[] {
let blocks: AnyDuringMigration[];
if (ordered) {
// Slow, but ordered.
const topBlocks = this.getTopBlocks(true);
@@ -385,9 +362,7 @@ class Workspace {
return filtered;
}
/**
* Dispose of all blocks and comments in workspace.
*/
/** Dispose of all blocks and comments in workspace. */
clear() {
this.isClearing = true;
try {
@@ -414,139 +389,137 @@ class Workspace {
}
/* Begin functions that are just pass-throughs to the variable map. */
/**
* 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.
* @param id ID of the variable to rename.
* @param newName New variable name.
*/
renameVariableById(id, newName) {
renameVariableById(id: string, newName: string) {
this.variableMap_.renameVariableById(id, newName);
}
/**
* 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'.
* @param name The name of the variable. This must be unique across variables
* and procedures.
* @param 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 {!VariableModel} The newly created variable.
* @param opt_id The unique ID of the variable. This will default to a UUID.
* @return The newly created variable.
*/
createVariable(name, opt_type, opt_id) {
createVariable(name: string, opt_type?: string|null, opt_id?: string|null):
VariableModel {
return this.variableMap_.createVariable(name, opt_type, opt_id);
}
/**
* Find all the uses of the given variable, which is identified by ID.
* @param {string} id ID of the variable to find.
* @return {!Array<!Block>} Array of block usages.
* @param id ID of the variable to find.
* @return Array of block usages.
*/
getVariableUsesById(id) {
getVariableUsesById(id: string): Block[] {
return this.variableMap_.getVariableUsesById(id);
}
/**
* 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.
* @param id ID of variable to delete.
*/
deleteVariableById(id) {
deleteVariableById(id: string) {
this.variableMap_.deleteVariableById(id);
}
/**
* 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 {?VariableModel} The variable with the given name.
* @param name The name to check for.
* @param opt_type The type of the variable. If not provided it defaults to
* the empty string, which is a specific type.
* @return The variable with the given name.
*/
getVariable(name, opt_type) {
getVariable(name: string, opt_type?: string): VariableModel|null {
// TODO (#1559): Possibly delete this function after resolving #1559.
return this.variableMap_.getVariable(name, opt_type);
}
/**
* Find the variable by the given ID and return it. Return null if not found.
* @param {string} id The ID to check for.
* @return {?VariableModel} The variable with the given ID.
* @param id The ID to check for.
* @return The variable with the given ID.
*/
getVariableById(id) {
getVariableById(id: string): VariableModel|null {
return this.variableMap_.getVariableById(id);
}
/**
* 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<!VariableModel>} The sought after variables of the
* passed in type. An empty array if none are found.
* @param type Type of the variables to find.
* @return The sought after variables of the passed in type. An empty array if
* none are found.
*/
getVariablesOfType(type) {
getVariablesOfType(type: string|null): VariableModel[] {
return this.variableMap_.getVariablesOfType(type);
}
/**
* Return all variable types.
* @return {!Array<string>} List of variable types.
* @package
* @return List of variable types.
* @internal
*/
getVariableTypes() {
getVariableTypes(): string[] {
return this.variableMap_.getVariableTypes(this);
}
/**
* Return all variables of all types.
* @return {!Array<!VariableModel>} List of variable models.
* @return List of variable models.
*/
getAllVariables() {
getAllVariables(): VariableModel[] {
return this.variableMap_.getAllVariables();
}
/**
* Returns all variable names of all types.
* @return {!Array<string>} List of all variable names of all types.
* @return List of all variable names of all types.
*/
getAllVariableNames() {
getAllVariableNames(): string[] {
return this.variableMap_.getAllVariableNames();
}
/* End functions that are just pass-throughs to the variable map. */
/**
* Returns the horizontal offset of the workspace.
* Intended for LTR/RTL compatibility in XML.
* Not relevant for a headless workspace.
* @return {number} Width.
* @return Width.
*/
getWidth() {
getWidth(): number {
return 0;
}
/**
* 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 {!Block} The created block.
* @param prototypeName Name of the language object containing type-specific
* functions for this block.
* @param opt_id Optional ID. Use this ID if provided, otherwise create a new
* ID.
* @return The created block.
*/
newBlock(prototypeName, opt_id) {
const {Block} = goog.module.get('Blockly.Block');
return new Block(this, prototypeName, opt_id);
newBlock(prototypeName: string, opt_id?: string): Block {
throw new Error(
'The implementation of newBlock should be ' +
'monkey-patched in by blockly.ts');
}
/**
* The number of blocks that may be added to the workspace before reaching
* the maxBlocks.
* @return {number} Number of blocks left.
* @return Number of blocks left.
*/
remainingCapacity() {
remainingCapacity(): number {
if (isNaN(this.options.maxBlocks)) {
return Infinity;
}
@@ -557,15 +530,15 @@ class Workspace {
/**
* 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.
* @param type Type of block to return capacity for.
* @return Number of blocks of type left.
*/
remainingCapacityOfType(type) {
remainingCapacityOfType(type: string): number {
if (!this.options.maxInstances) {
return Infinity;
}
const maxInstanceOfType = (this.options.maxInstances[type] !== undefined) ?
const maxInstanceOfType = this.options.maxInstances[type] !== undefined ?
this.options.maxInstances[type] :
Infinity;
@@ -577,13 +550,11 @@ class Workspace {
* 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.
* @param typeCountsMap A map of types to counts (usually representing blocks
* to be created).
* @return True if there is capacity for the given map, false otherwise.
*/
isCapacityAvailable(typeCountsMap) {
isCapacityAvailable(typeCountsMap: AnyDuringMigration): boolean {
if (!this.hasBlockLimits()) {
return true;
}
@@ -603,35 +574,35 @@ class Workspace {
/**
* 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.
* @return True if it has block limits, false otherwise.
*/
hasBlockLimits() {
hasBlockLimits(): boolean {
return this.options.maxBlocks !== Infinity || !!this.options.maxInstances;
}
/**
* Gets the undo stack for workplace.
* @return {!Array<!Abstract>} undo stack
* @package
* @return undo stack
* @internal
*/
getUndoStack() {
getUndoStack(): Abstract[] {
return this.undoStack_;
}
/**
* Gets the redo stack for workplace.
* @return {!Array<!Abstract>} redo stack
* @package
* @return redo stack
* @internal
*/
getRedoStack() {
getRedoStack(): Abstract[] {
return this.redoStack_;
}
/**
* Undo or redo the previous action.
* @param {boolean} redo False if undo, true if redo.
* @param redo False if undo, true if redo.
*/
undo(redo) {
undo(redo: boolean) {
const inputStack = redo ? this.redoStack_ : this.undoStack_;
const outputStack = redo ? this.undoStack_ : this.redoStack_;
const inputEvent = inputStack.pop();
@@ -642,7 +613,9 @@ class Workspace {
// Do another undo/redo if the next one is of the same group.
while (inputStack.length && inputEvent.group &&
inputEvent.group === inputStack[inputStack.length - 1].group) {
events.push(inputStack.pop());
// AnyDuringMigration because: Argument of type 'Abstract | undefined' is
// not assignable to parameter of type 'Abstract'.
events.push(inputStack.pop() as AnyDuringMigration);
}
// Push these popped events on the opposite stack.
for (let i = 0; i < events.length; i++) {
@@ -661,9 +634,7 @@ class Workspace {
}
}
/**
* Clear the undo/redo stacks.
*/
/** Clear the undo/redo stacks. */
clearUndo() {
this.undoStack_.length = 0;
this.redoStack_.length = 0;
@@ -676,27 +647,27 @@ class Workspace {
* 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.
* @param func Function to call.
* @return Obsolete return value, ignore.
*/
addChangeListener(func) {
addChangeListener(func: Function): Function {
this.listeners_.push(func);
return func;
}
/**
* Stop listening for this workspace's changes.
* @param {!Function} func Function to stop calling.
* @param func Function to stop calling.
*/
removeChangeListener(func) {
removeChangeListener(func: Function) {
arrayUtils.removeElem(this.listeners_, func);
}
/**
* Fire a change event.
* @param {!Abstract} event Event to fire.
* @param event Event to fire.
*/
fireChangeListener(event) {
fireChangeListener(event: Abstract) {
if (event.recordUndo) {
this.undoStack_.push(event);
this.redoStack_.length = 0;
@@ -712,52 +683,50 @@ class Workspace {
/**
* Find the block on this workspace with the specified ID.
* @param {string} id ID of block to find.
* @return {?Block} The sought after block, or null if not found.
* @param id ID of block to find.
* @return The sought after block, or null if not found.
*/
getBlockById(id) {
getBlockById(id: string): Block|null {
return this.blockDB_[id] || null;
}
/**
* Set a block on this workspace with the specified ID.
* @param {string} id ID of block to set.
* @param {Block} block The block to set.
* @package
* @param id ID of block to set.
* @param block The block to set.
* @internal
*/
setBlockById(id, block) {
setBlockById(id: string, block: Block) {
this.blockDB_[id] = block;
}
/**
* Delete a block off this workspace with the specified ID.
* @param {string} id ID of block to delete.
* @package
* @param id ID of block to delete.
* @internal
*/
removeBlockById(id) {
removeBlockById(id: string) {
delete this.blockDB_[id];
}
/**
* Find the comment on this workspace with the specified ID.
* @param {string} id ID of comment to find.
* @return {?WorkspaceComment} The sought after comment, or null if not
* found.
* @package
* @param id ID of comment to find.
* @return The sought after comment, or null if not found.
* @internal
*/
getCommentById(id) {
getCommentById(id: string): WorkspaceComment|null {
return this.commentDB_[id] || null;
}
/**
* 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.
* @param opt_shadowBlocksAreFilled An optional argument controlling whether
* shadow blocks are counted as filled. Defaults to true.
* @return True if all inputs are filled, false otherwise.
*/
allInputsFilled(opt_shadowBlocksAreFilled) {
allInputsFilled(opt_shadowBlocksAreFilled?: boolean): boolean {
const blocks = this.getTopBlocks(false);
for (let i = 0; i < blocks.length; i++) {
const block = blocks[i];
@@ -771,16 +740,16 @@ class Workspace {
/**
* Return the variable map that contains "potential" variables.
* These exist in the flyout but not in the workspace.
* @return {?VariableMap} The potential variable map.
* @package
* @return The potential variable map.
* @internal
*/
getPotentialVariableMap() {
getPotentialVariableMap(): VariableMap|null {
return this.potentialVariableMap_;
}
/**
* Create and store the potential variable map for this workspace.
* @package
* @internal
*/
createPotentialVariableMap() {
this.potentialVariableMap_ = new VariableMap(this);
@@ -788,49 +757,35 @@ class Workspace {
/**
* Return the map of all variables on the workspace.
* @return {!VariableMap} The variable map.
* @return The variable map.
*/
getVariableMap() {
getVariableMap(): VariableMap {
return this.variableMap_;
}
/**
* Set the map of all variables on the workspace.
* @param {!VariableMap} variableMap The variable map.
* @package
* @param variableMap The variable map.
* @internal
*/
setVariableMap(variableMap) {
setVariableMap(variableMap: VariableMap) {
this.variableMap_ = variableMap;
}
/**
* Find the workspace with the specified ID.
* @param {string} id ID of workspace to find.
* @return {?Workspace} The sought after workspace or null if not found.
* @param id ID of workspace to find.
* @return The sought after workspace or null if not found.
*/
static getById(id) {
return WorkspaceDB_[id] || null;
static getById(id: string): Workspace|null {
return common.getWorkspaceById(id);
}
/**
* Find all workspaces.
* @return {!Array<!Workspace>} Array of workspaces.
* @return Array of workspaces.
*/
static getAll() {
const workspaces = [];
for (const workspaceId in WorkspaceDB_) {
workspaces.push(WorkspaceDB_[workspaceId]);
}
return workspaces;
static getAll(): Workspace[] {
return common.getAllWorkspaces();
}
}
/**
* 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
*/
Workspace.SCAN_ANGLE = 3;
exports.Workspace = Workspace;