blockly 8.0.4 → 8.0.5-beta.0

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

@@ -7,65 +7,69 @@
 /**
  * @fileoverview Functions for injecting Blockly into a web page.
  */
-'use strict';
 
 /**
  * Functions for injecting Blockly into a web page.
  * @namespace Blockly.inject
  */
-goog.module('Blockly.inject');
-
-const Css = goog.require('Blockly.Css');
-const Tooltip = goog.require('Blockly.Tooltip');
-const Touch = goog.require('Blockly.Touch');
-const WidgetDiv = goog.require('Blockly.WidgetDiv');
-const aria = goog.require('Blockly.utils.aria');
-const browserEvents = goog.require('Blockly.browserEvents');
-const bumpObjects = goog.require('Blockly.bumpObjects');
-const common = goog.require('Blockly.common');
-const dom = goog.require('Blockly.utils.dom');
-const dropDownDiv = goog.require('Blockly.dropDownDiv');
-const userAgent = goog.require('Blockly.utils.userAgent');
-const {BlockDragSurfaceSvg} = goog.require('Blockly.BlockDragSurfaceSvg');
-/* eslint-disable-next-line no-unused-vars */
-const {BlocklyOptions} = goog.requireType('Blockly.BlocklyOptions');
-const {Grid} = goog.require('Blockly.Grid');
-const {Msg} = goog.require('Blockly.Msg');
-const {Options} = goog.require('Blockly.Options');
-const {ScrollbarPair} = goog.require('Blockly.ScrollbarPair');
-const {ShortcutRegistry} = goog.require('Blockly.ShortcutRegistry');
-const {Svg} = goog.require('Blockly.utils.Svg');
-const {WorkspaceDragSurfaceSvg} = goog.require('Blockly.WorkspaceDragSurfaceSvg');
-const {WorkspaceSvg} = goog.require('Blockly.WorkspaceSvg');
-const {Workspace} = goog.require('Blockly.Workspace');
+import * as goog from '../closure/goog/goog.js';
+goog.declareModuleId('Blockly.inject');
+
+import {BlockDragSurfaceSvg} from './block_drag_surface.js';
+import type {BlocklyOptions} from './blockly_options.js';
+import * as browserEvents from './browser_events.js';
+import * as bumpObjects from './bump_objects.js';
+import * as common from './common.js';
+import * as Css from './css.js';
+import * as dropDownDiv from './dropdowndiv.js';
+import {Grid} from './grid.js';
+import {Msg} from './msg.js';
+import {Options} from './options.js';
+import {ScrollbarPair} from './scrollbar_pair.js';
+import {ShortcutRegistry} from './shortcut_registry.js';
+import * as Tooltip from './tooltip.js';
+import * as Touch from './touch.js';
+import * as aria from './utils/aria.js';
+import * as dom from './utils/dom.js';
+import {Svg} from './utils/svg.js';
+import * as userAgent from './utils/useragent.js';
+import * as WidgetDiv from './widgetdiv.js';
+import {Workspace} from './workspace.js';
+import {WorkspaceDragSurfaceSvg} from './workspace_drag_surface_svg.js';
+import {WorkspaceSvg} from './workspace_svg.js';
 
 
 /**
  * Inject a Blockly editor into the specified container element (usually a div).
- * @param {Element|string} container Containing element, or its ID,
- *     or a CSS selector.
- * @param {BlocklyOptions=} opt_options Optional dictionary of options.
- * @return {!WorkspaceSvg} Newly created main workspace.
+ * @param container Containing element, or its ID, or a CSS selector.
+ * @param opt_options Optional dictionary of options.
+ * @return Newly created main workspace.
  * @alias Blockly.inject
  */
-const inject = function(container, opt_options) {
+export function inject(
+    container: Element|string, opt_options?: BlocklyOptions): WorkspaceSvg {
   if (typeof container === 'string') {
-    container =
-        document.getElementById(container) || document.querySelector(container);
+    // AnyDuringMigration because:  Type 'Element | null' is not assignable to
+    // type 'string | Element'.
+    container = (document.getElementById(container) ||
+                 document.querySelector(container)) as AnyDuringMigration;
   }
   // Verify that the container is in document.
-  if (!container || !dom.containsNode(document, container)) {
+  // AnyDuringMigration because:  Argument of type 'string | Element' is not
+  // assignable to parameter of type 'Node'.
+  if (!container ||
+      !dom.containsNode(document, container as AnyDuringMigration)) {
     throw Error('Error: container is not in current document.');
   }
-  const options =
-      new Options(opt_options || (/** @type {!BlocklyOptions} */ ({})));
-  const subContainer =
-      /** @type {!HTMLDivElement} */ (document.createElement('div'));
+  const options = new Options(opt_options || {} as BlocklyOptions);
+  const subContainer = (document.createElement('div'));
   subContainer.className = 'injectionDiv';
   subContainer.tabIndex = 0;
   aria.setState(subContainer, aria.State.LABEL, Msg['WORKSPACE_ARIA_LABEL']);
 
-  container.appendChild(subContainer);
+  // AnyDuringMigration because:  Property 'appendChild' does not exist on type
+  // 'string | Element'.
+  (container as AnyDuringMigration).appendChild(subContainer);
   const svg = createDom(subContainer, options);
 
   // Create surfaces for dragging things. These are optimizations
@@ -81,24 +85,28 @@ const inject = function(container, opt_options) {
 
   // Keep focus on the first workspace so entering keyboard navigation looks
   // correct.
-  common.setMainWorkspace(workspace);
+  // AnyDuringMigration because:  Argument of type 'WorkspaceSvg' is not
+  // assignable to parameter of type 'Workspace'.
+  common.setMainWorkspace(workspace as AnyDuringMigration);
 
   common.svgResize(workspace);
 
   subContainer.addEventListener('focusin', function() {
-    common.setMainWorkspace(workspace);
+    // AnyDuringMigration because:  Argument of type 'WorkspaceSvg' is not
+    // assignable to parameter of type 'Workspace'.
+    common.setMainWorkspace(workspace as AnyDuringMigration);
   });
 
   return workspace;
-};
+}
 
 /**
  * Create the SVG image.
- * @param {!Element} container Containing element.
- * @param {!Options} options Dictionary of options.
- * @return {!Element} Newly created SVG image.
+ * @param container Containing element.
+ * @param options Dictionary of options.
+ * @return Newly created SVG image.
  */
-const createDom = function(container, options) {
+function createDom(container: Element, options: Options): Element {
   // Sadly browsers (Chrome vs Firefox) are currently inconsistent in laying
   // out content in RTL mode.  Therefore Blockly forces the use of LTR,
   // then manually positions content in RTL as needed.
@@ -109,15 +117,15 @@ const createDom = function(container, options) {
 
   // Build the SVG DOM.
   /*
-  <svg
-    xmlns="http://www.w3.org/2000/svg"
-    xmlns:html="http://www.w3.org/1999/xhtml"
-    xmlns:xlink="http://www.w3.org/1999/xlink"
-    version="1.1"
-    class="blocklySvg">
-    ...
-  </svg>
-  */
+    <svg
+      xmlns="http://www.w3.org/2000/svg"
+      xmlns:html="http://www.w3.org/1999/xhtml"
+      xmlns:xlink="http://www.w3.org/1999/xlink"
+      version="1.1"
+      class="blocklySvg">
+      ...
+    </svg>
+    */
   const svg = dom.createSvgElement(
       Svg.SVG, {
         'xmlns': dom.SVG_NS,
@@ -129,10 +137,10 @@ const createDom = function(container, options) {
       },
       container);
   /*
-  <defs>
-    ... filters go here ...
-  </defs>
-  */
+    <defs>
+      ... filters go here ...
+    </defs>
+    */
   const defs = dom.createSvgElement(Svg.DEFS, {}, svg);
   // Each filter/pattern needs a unique ID for the case of multiple Blockly
   // instances on a page.  Browser behaviour becomes undefined otherwise.
@@ -141,20 +149,19 @@ const createDom = function(container, options) {
 
   options.gridPattern = Grid.createDom(rnd, options.gridOptions, defs);
   return svg;
-};
+}
 
 /**
  * Create a main workspace and add it to the SVG.
- * @param {!Element} svg SVG element with pattern defined.
- * @param {!Options} options Dictionary of options.
- * @param {!BlockDragSurfaceSvg} blockDragSurface Drag surface SVG
- *     for the blocks.
- * @param {!WorkspaceDragSurfaceSvg} workspaceDragSurface Drag surface
- *     SVG for the workspace.
- * @return {!WorkspaceSvg} Newly created main workspace.
+ * @param svg SVG element with pattern defined.
+ * @param options Dictionary of options.
+ * @param blockDragSurface Drag surface SVG for the blocks.
+ * @param workspaceDragSurface Drag surface SVG for the workspace.
+ * @return Newly created main workspace.
  */
-const createMainWorkspace = function(
-    svg, options, blockDragSurface, workspaceDragSurface) {
+function createMainWorkspace(
+    svg: Element, options: Options, blockDragSurface: BlockDragSurfaceSvg,
+    workspaceDragSurface: WorkspaceDragSurfaceSvg): WorkspaceSvg {
   options.parentWorkspace = null;
   const mainWorkspace =
       new WorkspaceSvg(options, blockDragSurface, workspaceDragSurface);
@@ -196,20 +203,20 @@ const createMainWorkspace = function(
   dropDownDiv.createDom();
   Tooltip.createDom();
   return mainWorkspace;
-};
+}
 
 /**
  * Initialize Blockly with various handlers.
- * @param {!WorkspaceSvg} mainWorkspace Newly created main workspace.
+ * @param mainWorkspace Newly created main workspace.
  */
-const init = function(mainWorkspace) {
+function init(mainWorkspace: WorkspaceSvg) {
   const options = mainWorkspace.options;
   const svg = mainWorkspace.getParentSvg();
 
   // Suppress the browser's context menu.
   browserEvents.conditionalBind(
-      /** @type {!Element} */ (svg.parentNode), 'contextmenu', null,
-      function(e) {
+      svg.parentNode as Element, 'contextmenu', null,
+      function(e: AnyDuringMigration) {
         if (!browserEvents.isTargetInput(e)) {
           e.preventDefault();
         }
@@ -219,8 +226,7 @@ const init = function(mainWorkspace) {
       browserEvents.conditionalBind(window, 'resize', null, function() {
         mainWorkspace.hideChaff(true);
         common.svgResize(mainWorkspace);
-        goog.module.get('Blockly.bumpObjects')
-            .bumpTopObjectsIntoBounds(mainWorkspace);
+        bumpObjects.bumpTopObjectsIntoBounds(mainWorkspace);
       });
   mainWorkspace.setResizeHandlerWrapper(workspaceResizeHandler);
 
@@ -265,36 +271,34 @@ const init = function(mainWorkspace) {
   if (options.hasSounds) {
     loadSounds(options.pathToMedia, mainWorkspace);
   }
-};
+}
 
 /**
  * Handle a key-down on SVG drawing surface. Does nothing if the main workspace
  * is not visible.
- * @param {!KeyboardEvent} e Key down event.
+ * @param e Key down event.
  */
 // TODO (https://github.com/google/blockly/issues/1998) handle cases where there
 // are multiple workspaces and non-main workspaces are able to accept input.
-const onKeyDown = function(e) {
-  const mainWorkspace =
-      /** @type {!WorkspaceSvg} */ (common.getMainWorkspace());
+function onKeyDown(e: KeyboardEvent) {
+  const mainWorkspace = common.getMainWorkspace() as WorkspaceSvg;
   if (!mainWorkspace) {
     return;
   }
 
   if (browserEvents.isTargetInput(e) ||
-      (mainWorkspace.rendered && !mainWorkspace.isVisible())) {
+      mainWorkspace.rendered && !mainWorkspace.isVisible()) {
     // When focused on an HTML text input widget, don't trap any keys.
     // Ignore keypresses on rendered workspaces that have been explicitly
     // hidden.
     return;
   }
   ShortcutRegistry.registry.onKeyDown(mainWorkspace, e);
-};
+}
 
 /**
  * Whether event handlers have been bound. Document event handlers will only
  * be bound once, even if Blockly is destroyed and reinjected.
- * @type {boolean}
  */
 let documentEventsBound = false;
 
@@ -308,12 +312,12 @@ let documentEventsBound = false;
  * Also, 'keydown' has to be on the whole document since the browser doesn't
  * understand a concept of focus on the SVG image.
  */
-const bindDocumentEvents = function() {
+function bindDocumentEvents() {
   if (!documentEventsBound) {
     browserEvents.conditionalBind(document, 'scroll', null, function() {
-      const workspaces = Workspace.getAll();
-      for (let i = 0, workspace; (workspace = workspaces[i]); i++) {
-        if (workspace.updateInverseScreenCTM) {
+      const workspaces = common.getAllWorkspaces();
+      for (let i = 0, workspace; workspace = workspaces[i]; i++) {
+        if (workspace instanceof WorkspaceSvg) {
           workspace.updateInverseScreenCTM();
         }
       }
@@ -328,20 +332,19 @@ const bindDocumentEvents = function() {
       browserEvents.conditionalBind(
           window, 'orientationchange', document, function() {
             // TODO (#397): Fix for multiple Blockly workspaces.
-            common.svgResize(/** @type {!WorkspaceSvg} */
-                             (common.getMainWorkspace()));
+            common.svgResize(common.getMainWorkspace() as WorkspaceSvg);
           });
     }
   }
   documentEventsBound = true;
-};
+}
 
 /**
  * Load sounds for the given workspace.
- * @param {string} pathToMedia The path to the media directory.
- * @param {!WorkspaceSvg} workspace The workspace to load sounds for.
+ * @param pathToMedia The path to the media directory.
+ * @param workspace The workspace to load sounds for.
  */
-const loadSounds = function(pathToMedia, workspace) {
+function loadSounds(pathToMedia: string, workspace: WorkspaceSvg) {
   const audioMgr = workspace.getAudioManager();
   audioMgr.load(
       [
@@ -366,13 +369,13 @@ const loadSounds = function(pathToMedia, workspace) {
       'delete');
 
   // Bind temporary hooks that preload the sounds.
-  const soundBinds = [];
-  const unbindSounds = function() {
+  const soundBinds: AnyDuringMigration[] = [];
+  function unbindSounds() {
     while (soundBinds.length) {
       browserEvents.unbind(soundBinds.pop());
     }
     audioMgr.preload();
-  };
+  }
 
   // These are bound on mouse/touch events with
   // Blockly.browserEvents.conditionalBind, so they restrict the touch
@@ -384,6 +387,4 @@ const loadSounds = function(pathToMedia, workspace) {
       document, 'mousemove', null, unbindSounds, true));
   soundBinds.push(browserEvents.conditionalBind(
       document, 'touchstart', null, unbindSounds, true));
-};
-
-exports.inject = inject;
+}

package/core/input.d.ts

@@ -0,0 +1,128 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import './field_label.js';
+import type { Block } from './block.js';
+import type { BlockSvg } from './block_svg.js';
+import type { Connection } from './connection.js';
+import type { Field } from './field.js';
+/**
+ * Class for an input with an optional field.
+ * @alias Blockly.Input
+ */
+export declare class Input {
+    type: number;
+    name: string;
+    connection: Connection | null;
+    private sourceBlock_;
+    fieldRow: Field[];
+    align: Align;
+    /** Is the input visible? */
+    private visible_;
+    /**
+     * @param type The type of the input.
+     * @param name Language-neutral identifier which may used to find this input
+     *     again.
+     * @param block The block containing this input.
+     * @param connection Optional connection for this input.
+     */
+    constructor(type: number, name: string, block: Block, connection: Connection | null);
+    /**
+     * Get the source block for this input.
+     * @return The source block, or null if there is none.
+     */
+    getSourceBlock(): Block;
+    /**
+     * Add a field (or label from string), and all prefix and suffix fields, to
+     * the end of the input's field row.
+     * @param field Something to add as a field.
+     * @param opt_name Language-neutral identifier which may used to find this
+     *     field again.  Should be unique to the host block.
+     * @return The input being append to (to allow chaining).
+     */
+    appendField(field: string | Field, opt_name?: string): Input;
+    /**
+     * Inserts a field (or label from string), and all prefix and suffix fields,
+     * at the location of the input's field row.
+     * @param index The index at which to insert field.
+     * @param field Something to add as a field.
+     * @param opt_name Language-neutral identifier which may used to find this
+     *     field again.  Should be unique to the host block.
+     * @return The index following the last inserted field.
+     */
+    insertFieldAt(index: number, field: string | Field, opt_name?: string): number;
+    /**
+     * Remove a field from this input.
+     * @param name The name of the field.
+     * @param opt_quiet True to prevent an error if field is not present.
+     * @return True if operation succeeds, false if field is not present and
+     *     opt_quiet is true.
+     * @throws {Error} if the field is not present and opt_quiet is false.
+     */
+    removeField(name: string, opt_quiet?: boolean): boolean;
+    /**
+     * Gets whether this input is visible or not.
+     * @return True if visible.
+     */
+    isVisible(): boolean;
+    /**
+     * Sets whether this input is visible or not.
+     * Should only be used to collapse/uncollapse a block.
+     * @param visible True if visible.
+     * @return List of blocks to render.
+     * @internal
+     */
+    setVisible(visible: boolean): BlockSvg[];
+    /**
+     * Mark all fields on this input as dirty.
+     * @internal
+     */
+    markDirty(): void;
+    /**
+     * Change a connection's compatibility.
+     * @param check Compatible value type or list of value types.  Null if all
+     *     types are compatible.
+     * @return The input being modified (to allow chaining).
+     */
+    setCheck(check: string | string[] | null): Input;
+    /**
+     * Change the alignment of the connection's field(s).
+     * @param align One of the values of Align.  In RTL mode directions
+     *     are reversed, and Align.RIGHT aligns to the left.
+     * @return The input being modified (to allow chaining).
+     */
+    setAlign(align: Align): Input;
+    /**
+     * Changes the connection's shadow block.
+     * @param shadow DOM representation of a block or null.
+     * @return The input being modified (to allow chaining).
+     */
+    setShadowDom(shadow: Element | null): Input;
+    /**
+     * Returns the XML representation of the connection's shadow block.
+     * @return Shadow DOM representation of a block or null.
+     */
+    getShadowDom(): Element | null;
+    /** Initialize the fields on this input. */
+    init(): void;
+    /**
+     * Sever all links to this input.
+     * @suppress {checkTypes}
+     */
+    dispose(): void;
+}
+export declare namespace Input {
+    /**
+     * Enum for alignment of inputs.
+     * @alias Blockly.Input.Align
+     */
+    enum Align {
+        LEFT = -1,
+        CENTRE = 0,
+        RIGHT = 1
+    }
+}
+export declare type Align = Input.Align;
+export declare const Align: typeof Input.Align;