blockly 9.0.0-beta.0 → 9.0.0-beta.2

package/core/utils/toolbox.ts

@@ -1,433 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Utility functions for the toolbox and flyout.
- */
-
-/**
- * Utility functions for the toolbox and flyout.
- * @namespace Blockly.utils.toolbox
- */
-import * as goog from '../../closure/goog/goog.js';
-goog.declareModuleId('Blockly.utils.toolbox');
-
-/* eslint-disable-next-line no-unused-vars */
-// Unused import preserved for side-effects. Remove if unneeded.
-// import '../toolbox/category.js';
-/* eslint-disable-next-line no-unused-vars */
-// Unused import preserved for side-effects. Remove if unneeded.
-// import '../toolbox/separator.js';
-
-import type {ConnectionState} from '../serialization/blocks.js';
-import type {CssConfig as CategoryCssConfig} from '../toolbox/category.js';
-import type {CssConfig as SeparatorCssConfig} from '../toolbox/separator.js';
-import * as Xml from '../xml.js';
-import * as userAgent from './useragent.js';
-
-
-/**
- * The information needed to create a block in the toolbox.
- * Note that disabled has a different type for backwards compatibility.
- * @alias Blockly.utils.toolbox.BlockInfo
- */
-export interface BlockInfo {
-  kind: string;
-  blockxml?: string|Node;
-  type?: string;
-  gap?: string|number;
-  disabled?: string|boolean;
-  enabled?: boolean;
-  id?: string;
-  x?: number;
-  y?: number;
-  collapsed?: boolean;
-  inline?: boolean;
-  data?: string;
-  extraState?: AnyDuringMigration;
-  icons?: {[key: string]: AnyDuringMigration};
-  fields?: {[key: string]: AnyDuringMigration};
-  inputs?: {[key: string]: ConnectionState};
-  next?: ConnectionState;
-}
-
-/**
- * The information needed to create a separator in the toolbox.
- * @alias Blockly.utils.toolbox.SeparatorInfo
- */
-export interface SeparatorInfo {
-  kind: string;
-  id: string|undefined;
-  gap: number|undefined;
-  cssconfig: SeparatorCssConfig|undefined;
-}
-
-/**
- * The information needed to create a button in the toolbox.
- * @alias Blockly.utils.toolbox.ButtonInfo
- */
-export interface ButtonInfo {
-  kind: string;
-  text: string;
-  callbackkey: string;
-}
-
-/**
- * The information needed to create a label in the toolbox.
- * @alias Blockly.utils.toolbox.LabelInfo
- */
-export interface LabelInfo {
-  kind: string;
-  text: string;
-  id: string|undefined;
-}
-
-/**
- * The information needed to create either a button or a label in the flyout.
- * @alias Blockly.utils.toolbox.ButtonOrLabelInfo
- */
-export type ButtonOrLabelInfo = ButtonInfo|LabelInfo;
-
-/**
- * The information needed to create a category in the toolbox.
- * @alias Blockly.utils.toolbox.StaticCategoryInfo
- */
-export interface StaticCategoryInfo {
-  kind: string;
-  name: string;
-  contents: ToolboxItemInfo[];
-  id: string|undefined;
-  categorystyle: string|undefined;
-  colour: string|undefined;
-  cssconfig: CategoryCssConfig|undefined;
-  hidden: string|undefined;
-}
-
-/**
- * The information needed to create a custom category.
- * @alias Blockly.utils.toolbox.DynamicCategoryInfo
- */
-export interface DynamicCategoryInfo {
-  kind: string;
-  custom: string;
-  id: string|undefined;
-  categorystyle: string|undefined;
-  colour: string|undefined;
-  cssconfig: CategoryCssConfig|undefined;
-  hidden: string|undefined;
-}
-
-/**
- * The information needed to create either a dynamic or static category.
- * @alias Blockly.utils.toolbox.CategoryInfo
- */
-export type CategoryInfo = StaticCategoryInfo|DynamicCategoryInfo;
-
-/**
- * Any information that can be used to create an item in the toolbox.
- * @alias Blockly.utils.toolbox.ToolboxItemInfo
- */
-export type ToolboxItemInfo = FlyoutItemInfo|StaticCategoryInfo;
-
-/**
- * All the different types that can be displayed in a flyout.
- * @alias Blockly.utils.toolbox.FlyoutItemInfo
- */
-export type FlyoutItemInfo =
-    BlockInfo|SeparatorInfo|ButtonInfo|LabelInfo|DynamicCategoryInfo;
-
-/**
- * The JSON definition of a toolbox.
- * @alias Blockly.utils.toolbox.ToolboxInfo
- */
-export interface ToolboxInfo {
-  kind?: string;
-  contents: ToolboxItemInfo[];
-}
-
-/**
- * An array holding flyout items.
- * @alias Blockly.utils.toolbox.FlyoutItemInfoArray
- */
-export type FlyoutItemInfoArray = FlyoutItemInfo[];
-
-/**
- * All of the different types that can create a toolbox.
- * @alias Blockly.utils.toolbox.ToolboxDefinition
- */
-export type ToolboxDefinition = Node|ToolboxInfo|string;
-
-/**
- * All of the different types that can be used to show items in a flyout.
- * @alias Blockly.utils.toolbox.FlyoutDefinition
- */
-export type FlyoutDefinition = FlyoutItemInfoArray|NodeList|ToolboxInfo|Node[];
-
-/**
- * The name used to identify a toolbox that has category like items.
- * This only needs to be used if a toolbox wants to be treated like a category
- * toolbox but does not actually contain any toolbox items with the kind
- * 'category'.
- */
-const CATEGORY_TOOLBOX_KIND = 'categoryToolbox';
-
-/**
- * The name used to identify a toolbox that has no categories and is displayed
- * as a simple flyout displaying blocks, buttons, or labels.
- */
-const FLYOUT_TOOLBOX_KIND = 'flyoutToolbox';
-
-/**
- * Position of the toolbox and/or flyout relative to the workspace.
- * @alias Blockly.utils.toolbox.Position
- */
-export enum Position {
-  TOP,
-  BOTTOM,
-  LEFT,
-  RIGHT
-}
-
-/**
- * Converts the toolbox definition into toolbox JSON.
- * @param toolboxDef The definition of the toolbox in one of its many forms.
- * @return Object holding information for creating a toolbox.
- * @alias Blockly.utils.toolbox.convertToolboxDefToJson
- * @internal
- */
-export function convertToolboxDefToJson(toolboxDef: ToolboxDefinition|
-                                        null): ToolboxInfo|null {
-  if (!toolboxDef) {
-    return null;
-  }
-
-  if (toolboxDef instanceof Element || typeof toolboxDef === 'string') {
-    toolboxDef = parseToolboxTree(toolboxDef);
-    // AnyDuringMigration because:  Argument of type 'Node | null' is not
-    // assignable to parameter of type 'Node'.
-    toolboxDef = convertToToolboxJson(toolboxDef as AnyDuringMigration);
-  }
-
-  const toolboxJson = toolboxDef as ToolboxInfo;
-  validateToolbox(toolboxJson);
-  return toolboxJson;
-}
-
-/**
- * Validates the toolbox JSON fields have been set correctly.
- * @param toolboxJson Object holding information for creating a toolbox.
- * @throws {Error} if the toolbox is not the correct format.
- */
-function validateToolbox(toolboxJson: ToolboxInfo) {
-  const toolboxKind = toolboxJson['kind'];
-  const toolboxContents = toolboxJson['contents'];
-
-  if (toolboxKind) {
-    if (toolboxKind !== FLYOUT_TOOLBOX_KIND &&
-        toolboxKind !== CATEGORY_TOOLBOX_KIND) {
-      throw Error(
-          'Invalid toolbox kind ' + toolboxKind + '.' +
-          ' Please supply either ' + FLYOUT_TOOLBOX_KIND + ' or ' +
-          CATEGORY_TOOLBOX_KIND);
-    }
-  }
-  if (!toolboxContents) {
-    throw Error('Toolbox must have a contents attribute.');
-  }
-}
-
-/**
- * Converts the flyout definition into a list of flyout items.
- * @param flyoutDef The definition of the flyout in one of its many forms.
- * @return A list of flyout items.
- * @alias Blockly.utils.toolbox.convertFlyoutDefToJsonArray
- * @internal
- */
-export function convertFlyoutDefToJsonArray(flyoutDef: FlyoutDefinition|
-                                            null): FlyoutItemInfoArray {
-  if (!flyoutDef) {
-    return [];
-  }
-
-  if ((flyoutDef as AnyDuringMigration)['contents']) {
-    return (flyoutDef as AnyDuringMigration)['contents'];
-  }
-  // If it is already in the correct format return the flyoutDef.
-  // AnyDuringMigration because:  Property 'nodeType' does not exist on type
-  // 'Node | FlyoutItemInfo'.
-  if (Array.isArray(flyoutDef) && flyoutDef.length > 0 &&
-      !((flyoutDef[0]) as AnyDuringMigration).nodeType) {
-    // AnyDuringMigration because:  Type 'FlyoutItemInfoArray | Node[]' is not
-    // assignable to type 'FlyoutItemInfoArray'.
-    return flyoutDef as AnyDuringMigration;
-  }
-
-  // AnyDuringMigration because:  Type 'ToolboxItemInfo[] | FlyoutItemInfoArray'
-  // is not assignable to type 'FlyoutItemInfoArray'.
-  return xmlToJsonArray(flyoutDef as Node[] | NodeList) as AnyDuringMigration;
-}
-
-/**
- * Whether or not the toolbox definition has categories.
- * @param toolboxJson Object holding information for creating a toolbox.
- * @return True if the toolbox has categories.
- * @alias Blockly.utils.toolbox.hasCategories
- * @internal
- */
-export function hasCategories(toolboxJson: ToolboxInfo|null): boolean {
-  return TEST_ONLY.hasCategoriesInternal(toolboxJson);
-}
-
-/**
- * Private version of hasCategories for stubbing in tests.
- */
-function hasCategoriesInternal(toolboxJson: ToolboxInfo|null): boolean {
-  if (!toolboxJson) {
-    return false;
-  }
-
-  const toolboxKind = toolboxJson['kind'];
-  if (toolboxKind) {
-    return toolboxKind === CATEGORY_TOOLBOX_KIND;
-  }
-
-  const categories = toolboxJson['contents'].filter(function(item) {
-    return item['kind'].toUpperCase() === 'CATEGORY';
-  });
-  return !!categories.length;
-}
-
-/**
- * Whether or not the category is collapsible.
- * @param categoryInfo Object holing information for creating a category.
- * @return True if the category has subcategories.
- * @alias Blockly.utils.toolbox.isCategoryCollapsible
- * @internal
- */
-export function isCategoryCollapsible(categoryInfo: CategoryInfo): boolean {
-  if (!categoryInfo || !(categoryInfo as AnyDuringMigration)['contents']) {
-    return false;
-  }
-
-  const categories =
-      (categoryInfo as AnyDuringMigration)['contents'].filter(function(
-          item: AnyDuringMigration) {
-        return item['kind'].toUpperCase() === 'CATEGORY';
-      });
-  return !!categories.length;
-}
-
-/**
- * Parses the provided toolbox definition into a consistent format.
- * @param toolboxDef The definition of the toolbox in one of its many forms.
- * @return Object holding information for creating a toolbox.
- */
-function convertToToolboxJson(toolboxDef: Node): ToolboxInfo {
-  const contents = xmlToJsonArray(toolboxDef as Node | Node[]);
-  const toolboxJson = {'contents': contents};
-  if (toolboxDef instanceof Node) {
-    addAttributes(toolboxDef, toolboxJson);
-  }
-  return toolboxJson;
-}
-
-/**
- * Converts the xml for a toolbox to JSON.
- * @param toolboxDef The definition of the toolbox in one of its many forms.
- * @return A list of objects in the toolbox.
- */
-function xmlToJsonArray(toolboxDef: Node|Node[]|NodeList): FlyoutItemInfoArray|
-    ToolboxItemInfo[] {
-  const arr = [];
-  // If it is a node it will have children.
-  // AnyDuringMigration because:  Property 'childNodes' does not exist on type
-  // 'Node | NodeList | Node[]'.
-  let childNodes = (toolboxDef as AnyDuringMigration).childNodes;
-  if (!childNodes) {
-    // Otherwise the toolboxDef is an array or collection.
-    childNodes = toolboxDef;
-  }
-  for (let i = 0, child; child = childNodes[i]; i++) {
-    if (!child.tagName) {
-      continue;
-    }
-    const obj = {};
-    const tagName = child.tagName.toUpperCase();
-    (obj as AnyDuringMigration)['kind'] = tagName;
-
-    // Store the XML for a block.
-    if (tagName === 'BLOCK') {
-      (obj as AnyDuringMigration)['blockxml'] = child;
-    } else if (child.childNodes && child.childNodes.length > 0) {
-      // Get the contents of a category
-      (obj as AnyDuringMigration)['contents'] = xmlToJsonArray(child);
-    }
-
-    // Add XML attributes to object
-    addAttributes(child, obj);
-    arr.push(obj);
-  }
-  // AnyDuringMigration because:  Type '{}[]' is not assignable to type
-  // 'ToolboxItemInfo[] | FlyoutItemInfoArray'.
-  return arr as AnyDuringMigration;
-}
-
-/**
- * Adds the attributes on the node to the given object.
- * @param node The node to copy the attributes from.
- * @param obj The object to copy the attributes to.
- */
-function addAttributes(node: Node, obj: AnyDuringMigration) {
-  // AnyDuringMigration because:  Property 'attributes' does not exist on type
-  // 'Node'.
-  for (let j = 0; j < (node as AnyDuringMigration).attributes.length; j++) {
-    // AnyDuringMigration because:  Property 'attributes' does not exist on type
-    // 'Node'.
-    const attr = (node as AnyDuringMigration).attributes[j];
-    if (attr.nodeName.indexOf('css-') > -1) {
-      obj['cssconfig'] = obj['cssconfig'] || {};
-      obj['cssconfig'][attr.nodeName.replace('css-', '')] = attr.value;
-    } else {
-      obj[attr.nodeName] = attr.value;
-    }
-  }
-}
-
-/**
- * Parse the provided toolbox tree into a consistent DOM format.
- * @param toolboxDef DOM tree of blocks, or text representation of same.
- * @return DOM tree of blocks, or null.
- * @alias Blockly.utils.toolbox.parseToolboxTree
- */
-export function parseToolboxTree(toolboxDef: Element|null|string): Element|
-    null {
-  if (toolboxDef) {
-    if (typeof toolboxDef !== 'string') {
-      if (userAgent.IE && toolboxDef.outerHTML) {
-        // In this case the tree will not have been properly built by the
-        // browser. The HTML will be contained in the element, but it will
-        // not have the proper DOM structure since the browser doesn't support
-        // XSLTProcessor (XML -> HTML).
-        toolboxDef = toolboxDef.outerHTML;
-      } else if (!(toolboxDef instanceof Element)) {
-        toolboxDef = null;
-      }
-    }
-    if (typeof toolboxDef === 'string') {
-      toolboxDef = Xml.textToDom(toolboxDef);
-      if (toolboxDef.nodeName.toLowerCase() !== 'xml') {
-        throw TypeError('Toolbox should be an <xml> document.');
-      }
-    }
-  } else {
-    toolboxDef = null;
-  }
-  return toolboxDef;
-}
-
-export const TEST_ONLY = {
-  hasCategoriesInternal,
-}

package/core/utils/useragent.ts

@@ -1,135 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Useragent detection.
- * These methods are not specific to Blockly, and could be factored out into
- * a JavaScript framework such as Closure.
- */
-
-/**
- * Useragent detection.
- * These methods are not specific to Blockly, and could be factored out into
- * a JavaScript framework such as Closure.
- * @namespace Blockly.utils.userAgent
- */
-import * as goog from '../../closure/goog/goog.js';
-goog.declareModuleId('Blockly.utils.userAgent');
-
-
-/** The raw useragent string. */
-let rawUserAgent: string;
-
-let isIe: boolean;
-
-let isEdge: boolean;
-
-let isJavaFx: boolean;
-
-let isChrome: boolean;
-
-let isWebKit: boolean;
-
-let isGecko: boolean;
-
-let isAndroid: boolean;
-
-let isIPad: boolean;
-
-let isIPod: boolean;
-
-let isIPhone: boolean;
-
-let isMac: boolean;
-
-let isTablet: boolean;
-
-let isMobile: boolean;
-
-(function(raw) {
-rawUserAgent = raw;
-const rawUpper = rawUserAgent.toUpperCase();
-/**
- * Case-insensitive test of whether name is in the useragent string.
- * @param name Name to test.
- * @return True if name is present.
- */
-function has(name: string): boolean {
-  return rawUpper.indexOf(name.toUpperCase()) !== -1;
-}
-
-// Browsers.  Logic from:
-// https://github.com/google/closure-library/blob/master/closure/goog/labs/useragent/browser.js
-isIe = has('Trident') || has('MSIE');
-isEdge = has('Edge');
-// Useragent for JavaFX:
-// Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.44
-//     (KHTML, like Gecko) JavaFX/8.0 Safari/537.44
-isJavaFx = has('JavaFX');
-isChrome = (has('Chrome') || has('CriOS')) && !isEdge;
-
-// Engines.  Logic from:
-// https://github.com/google/closure-library/blob/master/closure/goog/labs/useragent/engine.js
-isWebKit = has('WebKit') && !isEdge;
-isGecko = has('Gecko') && !isWebKit && !isIe && !isEdge;
-
-// Platforms.  Logic from:
-// https://github.com/google/closure-library/blob/master/closure/goog/labs/useragent/platform.js
-// and
-// https://github.com/google/closure-library/blob/master/closure/goog/labs/useragent/extra.js
-isAndroid = has('Android');
-const maxTouchPoints =
-    globalThis['navigator'] && globalThis['navigator']['maxTouchPoints'];
-isIPad = has('iPad') || has('Macintosh') && maxTouchPoints > 0;
-isIPod = has('iPod');
-isIPhone = has('iPhone') && !isIPad && !isIPod;
-isMac = has('Macintosh');
-
-// Devices.  Logic from:
-// https://github.com/google/closure-library/blob/master/closure/goog/labs/useragent/device.js
-isTablet = isIPad || isAndroid && !has('Mobile') || has('Silk');
-isMobile = !isTablet && (isIPod || isIPhone || isAndroid || has('IEMobile'));
-})(globalThis['navigator'] && globalThis['navigator']['userAgent'] || '');
-
-/** @alias Blockly.utils.userAgent.raw */
-export const raw: string = rawUserAgent;
-
-/** @alias Blockly.utils.userAgent.IE */
-export const IE: boolean = isIe;
-
-/** @alias Blockly.utils.userAgent.EDGE */
-export const EDGE: boolean = isEdge;
-
-/** @alias Blockly.utils.userAgent.JavaFx */
-export const JavaFx: boolean = isJavaFx;
-
-/** @alias Blockly.utils.userAgent.CHROME */
-export const CHROME: boolean = isChrome;
-
-/** @alias Blockly.utils.userAgent.WEBKIT */
-export const WEBKIT: boolean = isWebKit;
-/** @alias Blockly.utils.userAgent.GECKO */
-export const GECKO: boolean = isGecko;
-
-/** @alias Blockly.utils.userAgent.ANDROID */
-export const ANDROID: boolean = isAndroid;
-
-/** @alias Blockly.utils.userAgent.IPAD */
-export const IPAD: boolean = isIPad;
-/** @alias Blockly.utils.userAgent.IPOD */
-export const IPOD: boolean = isIPod;
-
-/** @alias Blockly.utils.userAgent.IPHONE */
-export const IPHONE: boolean = isIPhone;
-
-/** @alias Blockly.utils.userAgent.MAC */
-export const MAC: boolean = isMac;
-
-/** @alias Blockly.utils.userAgent.TABLET */
-export const TABLET: boolean = isTablet;
-
-/** @alias Blockly.utils.userAgent.MOBILE */
-export const MOBILE: boolean = isMobile;

package/core/utils/xml.ts

@@ -1,97 +0,0 @@
-/**
- * @license
- * Copyright 2018 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview XML element manipulation.
- * These methods are not specific to Blockly, and could be factored out into
- * a JavaScript framework such as Closure.
- */
-
-/**
- * XML element manipulation.
- * These methods are not specific to Blockly, and could be factored out into
- * a JavaScript framework such as Closure.
- * @namespace Blockly.utils.xml
- */
-import * as goog from '../../closure/goog/goog.js';
-goog.declareModuleId('Blockly.utils.xml');
-
-
-/**
- * Namespace for Blockly's XML.
- * @alias Blockly.utils.xml.NAME_SPACE
- */
-export const NAME_SPACE = 'https://developers.google.com/blockly/xml';
-
-/**
- * The Document object to use.  By default this is just document, but
- * the Node.js build of Blockly (see scripts/package/node/core.js)
- * calls setDocument to supply a Document implementation from the
- * jsdom package instead.
- */
-let xmlDocument: Document = globalThis['document'];
-
-/**
- * Get the document object to use for XML serialization.
- * @return The document object.
- * @alias Blockly.utils.xml.getDocument
- */
-export function getDocument(): Document {
-  return xmlDocument;
-}
-
-/**
- * Get the document object to use for XML serialization.
- * @param document The document object to use.
- * @alias Blockly.utils.xml.setDocument
- */
-export function setDocument(document: Document) {
-  xmlDocument = document;
-}
-
-/**
- * Create DOM element for XML.
- * @param tagName Name of DOM element.
- * @return New DOM element.
- * @alias Blockly.utils.xml.createElement
- */
-export function createElement(tagName: string): Element {
-  return xmlDocument.createElementNS(NAME_SPACE, tagName);
-}
-
-/**
- * Create text element for XML.
- * @param text Text content.
- * @return New DOM text node.
- * @alias Blockly.utils.xml.createTextNode
- */
-export function createTextNode(text: string): Text {
-  return xmlDocument.createTextNode(text);
-}
-
-/**
- * Converts an XML string into a DOM tree.
- * @param text XML string.
- * @return The DOM document.
- * @throws if XML doesn't parse.
- * @alias Blockly.utils.xml.textToDomDocument
- */
-export function textToDomDocument(text: string): Document {
-  const oParser = new DOMParser();
-  return oParser.parseFromString(text, 'text/xml');
-}
-
-/**
- * Converts a DOM structure into plain text.
- * Currently the text format is fairly ugly: all one line with no whitespace.
- * @param dom A tree of XML nodes.
- * @return Text representation.
- * @alias Blockly.utils.xml.domToText
- */
-export function domToText(dom: Node): string {
-  const oSerializer = new XMLSerializer();
-  return oSerializer.serializeToString(dom);
-}