blockly 8.0.4-beta.0 → 8.0.5-beta.0

package/core/utils/toolbox.js

@@ -1,459 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Utility functions for the toolbox and flyout.
- */
-'use strict';
-
-/**
- * Utility functions for the toolbox and flyout.
- * @namespace Blockly.utils.toolbox
- */
-goog.module('Blockly.utils.toolbox');
-
-const Xml = goog.require('Blockly.Xml');
-const userAgent = goog.require('Blockly.utils.userAgent');
-/* eslint-disable-next-line no-unused-vars */
-const {ConnectionState} = goog.requireType('Blockly.serialization.blocks');
-/* eslint-disable-next-line no-unused-vars */
-const {ToolboxCategory} = goog.requireType('Blockly.ToolboxCategory');
-/* eslint-disable-next-line no-unused-vars */
-const {ToolboxSeparator} = goog.requireType('Blockly.ToolboxSeparator');
-
-/**
- * The information needed to create a block in the toolbox.
- * Note that disabled has a different type for backwards compatibility.
- * @typedef {{
- *            kind:string,
- *            blockxml:(string|!Node|undefined),
- *            type:(string|undefined),
- *            gap:(string|number|undefined),
- *            disabled: (string|boolean|undefined),
- *            enabled: (boolean|undefined),
- *            id: (string|undefined),
- *            x: (number|undefined),
- *            y: (number|undefined),
- *            collapsed: (boolean|undefined),
- *            inline: (boolean|undefined),
- *            data: (string|undefined),
- *            extra-state: (*|undefined),
- *            icons: (!Object<string, *>|undefined),
- *            fields: (!Object<string, *>|undefined),
- *            inputs: (!Object<string, !ConnectionState>|undefined),
- *            next: (!ConnectionState|undefined)
- *          }}
- * @alias Blockly.utils.toolbox.BlockInfo
- */
-let BlockInfo;
-exports.BlockInfo = BlockInfo;
-
-/**
- * The information needed to create a separator in the toolbox.
- * @typedef {{
- *            kind:string,
- *            id:(string|undefined),
- *            gap:(number|undefined),
- *            cssconfig:(!ToolboxSeparator.CssConfig|undefined)
- *          }}
- * @alias Blockly.utils.toolbox.SeparatorInfo
- */
-let SeparatorInfo;
-exports.SeparatorInfo = SeparatorInfo;
-
-/**
- * The information needed to create a button in the toolbox.
- * @typedef {{
- *            kind:string,
- *            text:string,
- *            callbackkey:string
- *          }}
- * @alias Blockly.utils.toolbox.ButtonInfo
- */
-let ButtonInfo;
-exports.ButtonInfo = ButtonInfo;
-
-/**
- * The information needed to create a label in the toolbox.
- * @typedef {{
- *            kind:string,
- *            text:string,
- *            id:(string|undefined)
- *          }}
- * @alias Blockly.utils.toolbox.LabelInfo
- */
-let LabelInfo;
-exports.LabelInfo = LabelInfo;
-
-/**
- * The information needed to create either a button or a label in the flyout.
- * @typedef {ButtonInfo|
- *           LabelInfo}
- * @alias Blockly.utils.toolbox.ButtonOrLabelInfo
- */
-let ButtonOrLabelInfo;
-exports.ButtonOrLabelInfo = ButtonOrLabelInfo;
-
-/**
- * The information needed to create a category in the toolbox.
- * @typedef {{
- *            kind:string,
- *            name:string,
- *            contents:!Array<!ToolboxItemInfo>,
- *            id:(string|undefined),
- *            categorystyle:(string|undefined),
- *            colour:(string|undefined),
- *            cssconfig:(!ToolboxCategory.CssConfig|undefined),
- *            hidden:(string|undefined)
- *          }}
- * @alias Blockly.utils.toolbox.StaticCategoryInfo
- */
-let StaticCategoryInfo;
-exports.StaticCategoryInfo = StaticCategoryInfo;
-
-/**
- * The information needed to create a custom category.
- * @typedef {{
- *            kind:string,
- *            custom:string,
- *            id:(string|undefined),
- *            categorystyle:(string|undefined),
- *            colour:(string|undefined),
- *            cssconfig:(!ToolboxCategory.CssConfig|undefined),
- *            hidden:(string|undefined)
- *          }}
- * @alias Blockly.utils.toolbox.DynamicCategoryInfo
- */
-let DynamicCategoryInfo;
-exports.DynamicCategoryInfo = DynamicCategoryInfo;
-
-/**
- * The information needed to create either a dynamic or static category.
- * @typedef {StaticCategoryInfo|
- *           DynamicCategoryInfo}
- * @alias Blockly.utils.toolbox.CategoryInfo
- */
-let CategoryInfo;
-exports.CategoryInfo = CategoryInfo;
-
-/**
- * Any information that can be used to create an item in the toolbox.
- * @typedef {FlyoutItemInfo|
- *           StaticCategoryInfo}
- * @alias Blockly.utils.toolbox.ToolboxItemInfo
- */
-let ToolboxItemInfo;
-exports.ToolboxItemInfo = ToolboxItemInfo;
-
-/**
- * All the different types that can be displayed in a flyout.
- * @typedef {BlockInfo|
- *           SeparatorInfo|
- *           ButtonInfo|
- *           LabelInfo|
- *           DynamicCategoryInfo}
- * @alias Blockly.utils.toolbox.FlyoutItemInfo
- */
-let FlyoutItemInfo;
-exports.FlyoutItemInfo = FlyoutItemInfo;
-
-/**
- * The JSON definition of a toolbox.
- * @typedef {{
- *            kind:(string|undefined),
- *            contents:!Array<!ToolboxItemInfo>
- *          }}
- * @alias Blockly.utils.toolbox.ToolboxInfo
- */
-let ToolboxInfo;
-exports.ToolboxInfo = ToolboxInfo;
-
-/**
- * An array holding flyout items.
- * @typedef {
- *            Array<!FlyoutItemInfo>
- *          }
- * @alias Blockly.utils.toolbox.FlyoutItemInfoArray
- */
-let FlyoutItemInfoArray;
-exports.FlyoutItemInfoArray = FlyoutItemInfoArray;
-
-/**
- * All of the different types that can create a toolbox.
- * @typedef {Node|
- *           ToolboxInfo|
- *           string}
- * @alias Blockly.utils.toolbox.ToolboxDefinition
- */
-let ToolboxDefinition;
-exports.ToolboxDefinition = ToolboxDefinition;
-
-/**
- * All of the different types that can be used to show items in a flyout.
- * @typedef {FlyoutItemInfoArray|
- *           NodeList|
- *           ToolboxInfo|
- *           Array<!Node>}
- * @alias Blockly.utils.toolbox.FlyoutDefinition
- */
-let FlyoutDefinition;
-exports.FlyoutDefinition = FlyoutDefinition;
-
-/**
- * The name used to identify a toolbox that has category like items.
- * This only needs to be used if a toolbox wants to be treated like a category
- * toolbox but does not actually contain any toolbox items with the kind
- * 'category'.
- * @const {string}
- */
-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 {string}
- */
-const FLYOUT_TOOLBOX_KIND = 'flyoutToolbox';
-
-/**
- * Position of the toolbox and/or flyout relative to the workspace.
- * @enum {number}
- * @alias Blockly.utils.toolbox.Position
- */
-const Position = {
-  TOP: 0,
-  BOTTOM: 1,
-  LEFT: 2,
-  RIGHT: 3,
-};
-exports.Position = Position;
-
-/**
- * Converts the toolbox definition into toolbox JSON.
- * @param {?ToolboxDefinition} toolboxDef The definition
- *     of the toolbox in one of its many forms.
- * @return {?ToolboxInfo} Object holding information
- *     for creating a toolbox.
- * @alias Blockly.utils.toolbox.convertToolboxDefToJson
- * @package
- */
-const convertToolboxDefToJson = function(toolboxDef) {
-  if (!toolboxDef) {
-    return null;
-  }
-
-  if (toolboxDef instanceof Element || typeof toolboxDef === 'string') {
-    toolboxDef = parseToolboxTree(toolboxDef);
-    toolboxDef = convertToToolboxJson(toolboxDef);
-  }
-
-  const toolboxJson = /** @type {ToolboxInfo} */ (toolboxDef);
-  validateToolbox(toolboxJson);
-  return toolboxJson;
-};
-exports.convertToolboxDefToJson = convertToolboxDefToJson;
-
-/**
- * Validates the toolbox JSON fields have been set correctly.
- * @param {!ToolboxInfo} toolboxJson Object holding
- *     information for creating a toolbox.
- * @throws {Error} if the toolbox is not the correct format.
- */
-const validateToolbox = function(toolboxJson) {
-  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 {?FlyoutDefinition} flyoutDef The definition of
- *    the flyout in one of its many forms.
- * @return {!FlyoutItemInfoArray} A list of flyout items.
- * @alias Blockly.utils.toolbox.convertFlyoutDefToJsonArray
- * @package
- */
-const convertFlyoutDefToJsonArray = function(flyoutDef) {
-  if (!flyoutDef) {
-    return [];
-  }
-
-  if (flyoutDef['contents']) {
-    return flyoutDef['contents'];
-  }
-
-  // If it is already in the correct format return the flyoutDef.
-  if (Array.isArray(flyoutDef) && flyoutDef.length > 0 &&
-      !flyoutDef[0].nodeType) {
-    return flyoutDef;
-  }
-
-  return xmlToJsonArray(/** @type {!Array<Node>|!NodeList} */ (flyoutDef));
-};
-exports.convertFlyoutDefToJsonArray = convertFlyoutDefToJsonArray;
-
-/**
- * Whether or not the toolbox definition has categories.
- * @param {?ToolboxInfo} toolboxJson Object holding
- *     information for creating a toolbox.
- * @return {boolean} True if the toolbox has categories.
- * @alias Blockly.utils.toolbox.hasCategories
- * @package
- */
-const hasCategories = function(toolboxJson) {
-  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;
-};
-exports.hasCategories = hasCategories;
-
-/**
- * Whether or not the category is collapsible.
- * @param {!CategoryInfo} categoryInfo Object holing
- *    information for creating a category.
- * @return {boolean} True if the category has subcategories.
- * @alias Blockly.utils.toolbox.isCategoryCollapsible
- * @package
- */
-const isCategoryCollapsible = function(categoryInfo) {
-  if (!categoryInfo || !categoryInfo['contents']) {
-    return false;
-  }
-
-  const categories = categoryInfo['contents'].filter(function(item) {
-    return item['kind'].toUpperCase() === 'CATEGORY';
-  });
-  return !!categories.length;
-};
-exports.isCategoryCollapsible = isCategoryCollapsible;
-
-/**
- * Parses the provided toolbox definition into a consistent format.
- * @param {Node} toolboxDef The definition of the toolbox in one of its many
- *     forms.
- * @return {!ToolboxInfo} Object holding information
- *     for creating a toolbox.
- */
-const convertToToolboxJson = function(toolboxDef) {
-  const contents = xmlToJsonArray(
-      /** @type {!Node|!Array<Node>} */ (toolboxDef));
-  const toolboxJson = {'contents': contents};
-  if (toolboxDef instanceof Node) {
-    addAttributes(toolboxDef, toolboxJson);
-  }
-  return toolboxJson;
-};
-
-/**
- * Converts the xml for a toolbox to JSON.
- * @param {!Node|!Array<Node>|!NodeList} toolboxDef The
- *     definition of the toolbox in one of its many forms.
- * @return {!FlyoutItemInfoArray|
- *          !Array<ToolboxItemInfo>} A list of objects in
- *          the toolbox.
- */
-const xmlToJsonArray = function(toolboxDef) {
-  const arr = [];
-  // If it is a node it will have children.
-  let childNodes = toolboxDef.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['kind'] = tagName;
-
-    // Store the XML for a block.
-    if (tagName === 'BLOCK') {
-      obj['blockxml'] = child;
-    } else if (child.childNodes && child.childNodes.length > 0) {
-      // Get the contents of a category
-      obj['contents'] = xmlToJsonArray(child);
-    }
-
-    // Add XML attributes to object
-    addAttributes(child, obj);
-    arr.push(obj);
-  }
-  return arr;
-};
-
-/**
- * Adds the attributes on the node to the given object.
- * @param {!Node} node The node to copy the attributes from.
- * @param {!Object} obj The object to copy the attributes to.
- */
-const addAttributes = function(node, obj) {
-  for (let j = 0; j < node.attributes.length; j++) {
-    const attr = node.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 {?Node|?string} toolboxDef DOM tree of blocks, or text representation
- *    of same.
- * @return {?Node} DOM tree of blocks, or null.
- * @alias Blockly.utils.toolbox.parseToolboxTree
- */
-const parseToolboxTree = function(toolboxDef) {
-  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;
-};
-exports.parseToolboxTree = parseToolboxTree;

package/core/utils/useragent.js

@@ -1,197 +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.
- */
-'use strict';
-
-/**
- * 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
- */
-goog.module('Blockly.utils.userAgent');
-
-const {globalThis} = goog.require('Blockly.utils.global');
-
-
-/**
- * The raw useragent string.
- * @type {string}
- */
-let rawUserAgent;
-
-/** @type {boolean} */
-let isIe;
-
-/** @type {boolean} */
-let isEdge;
-
-/** @type {boolean} */
-let isJavaFx;
-
-/** @type {boolean} */
-let isChrome;
-
-/** @type {boolean} */
-let isWebKit;
-
-/** @type {boolean} */
-let isGecko;
-
-/** @type {boolean} */
-let isAndroid;
-
-/** @type {boolean} */
-let isIPad;
-
-/** @type {boolean} */
-let isIPod;
-
-/** @type {boolean} */
-let isIPhone;
-
-/** @type {boolean} */
-let isMac;
-
-/** @type {boolean} */
-let isTablet;
-
-/** @type {boolean} */
-let isMobile;
-
-(function(raw) {
-rawUserAgent = raw;
-const rawUpper = rawUserAgent.toUpperCase();
-/**
- * Case-insensitive test of whether name is in the useragent string.
- * @param {string} name Name to test.
- * @return {boolean} True if name is present.
- */
-function has(name) {
-  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']) || '');
-
-/**
- * @const {string}
- * @alias Blockly.utils.userAgent.raw
- */
-exports.raw = rawUserAgent;
-
-/**
- * @const {boolean}
- * @alias Blockly.utils.userAgent.IE
- */
-exports.IE = isIe;
-
-/**
- * @const {boolean}
- * @alias Blockly.utils.userAgent.EDGE
- */
-exports.EDGE = isEdge;
-
-/**
- * @const {boolean}
- * @alias Blockly.utils.userAgent.JavaFx
- */
-exports.JavaFx = isJavaFx;
-
-/**
- * @const {boolean}
- * @alias Blockly.utils.userAgent.CHROME
- */
-exports.CHROME = isChrome;
-
-/**
- * @const {boolean}
- * @alias Blockly.utils.userAgent.WEBKIT
- */
-exports.WEBKIT = isWebKit;
-
-/**
- * @const {boolean}
- * @alias Blockly.utils.userAgent.GECKO
- */
-exports.GECKO = isGecko;
-
-/**
- * @const {boolean}
- * @alias Blockly.utils.userAgent.ANDROID
- */
-exports.ANDROID = isAndroid;
-
-/**
- * @const {boolean}
- * @alias Blockly.utils.userAgent.IPAD
- */
-exports.IPAD = isIPad;
-
-/**
- * @const {boolean}
- * @alias Blockly.utils.userAgent.IPOD
- */
-exports.IPOD = isIPod;
-
-/**
- * @const {boolean}
- * @alias Blockly.utils.userAgent.IPHONE
- */
-exports.IPHONE = isIPhone;
-
-/**
- * @const {boolean}
- * @alias Blockly.utils.userAgent.MAC
- */
-exports.MAC = isMac;
-
-/**
- * @const {boolean}
- * @alias Blockly.utils.userAgent.TABLET
- */
-exports.TABLET = isTablet;
-
-/**
- * @const {boolean}
- * @alias Blockly.utils.userAgent.MOBILE
- */
-exports.MOBILE = isMobile;