nodeskini 1.0.1 → 1.0.2

package/blocklySkini/blockly/core/field_multilineinput.js

@@ -0,0 +1,299 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Text Area field.
+ * @author fraser@google.com (Neil Fraser)
+ * @author Andrew Mee
+ * @author acbart@udel.edu (Austin Cory Bart)
+ */
+'use strict';
+
+goog.provide('Blockly.FieldMultilineInput');
+
+goog.require('Blockly.Css');
+goog.require('Blockly.DropDownDiv');
+goog.require('Blockly.FieldTextInput');
+goog.require('Blockly.utils');
+goog.require('Blockly.utils.aria');
+goog.require('Blockly.utils.Coordinate');
+goog.require('Blockly.utils.dom');
+goog.require('Blockly.utils.KeyCodes');
+goog.require('Blockly.utils.object');
+goog.require('Blockly.utils.Svg');
+goog.require('Blockly.utils.userAgent');
+
+
+/**
+ * Class for an editable text area field.
+ * @param {string=} opt_value The initial content of the field. Should cast to a
+ *    string. Defaults to an empty string if null or undefined.
+ * @param {Function=} opt_validator An optional function that is called
+ *     to validate any constraints on what the user entered.  Takes the new
+ *     text as an argument and returns either the accepted text, a replacement
+ *     text, or null to abort the change.
+ * @param {Object=} opt_config A map of options used to configure the field.
+ *    See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/text-input#creation}
+ *    for a list of properties this parameter supports.
+ * @extends {Blockly.FieldTextInput}
+ * @constructor
+ */
+Blockly.FieldMultilineInput = function(opt_value, opt_validator, opt_config) {
+  // TODO: Once this field is documented the opt_config link should point to its
+  //  creation documentation, rather than the text input field's.
+  Blockly.FieldMultilineInput.superClass_.constructor.call(this,
+      opt_value, opt_validator, opt_config);
+
+  /**
+   * The SVG group element that will contain a text element for each text row
+   *     when initialized.
+   * @type {SVGGElement}
+   */
+  this.textGroup_ = null;
+};
+Blockly.utils.object.inherits(Blockly.FieldMultilineInput,
+    Blockly.FieldTextInput);
+
+/**
+ * Construct a FieldMultilineInput from a JSON arg object,
+ * dereferencing any string table references.
+ * @param {!Object} options A JSON object with options (text, and spellcheck).
+ * @return {!Blockly.FieldMultilineInput} The new field instance.
+ * @package
+ * @nocollapse
+ */
+Blockly.FieldMultilineInput.fromJson = function(options) {
+  var text = Blockly.utils.replaceMessageReferences(options['text']);
+  return new Blockly.FieldMultilineInput(text, undefined, options);
+};
+
+/**
+ * Serializes this field's value to XML. Should only be called by Blockly.Xml.
+ * @param {!Element} fieldElement The element to populate with info about the
+ *    field's state.
+ * @return {!Element} The element containing info about the field's state.
+ * @package
+ */
+Blockly.FieldMultilineInput.prototype.toXml = function(fieldElement) {
+  // Replace '\n' characters with html-escaped equivalent '&#10'. This is
+  // needed so the plain-text representation of the xml produced by
+  // `Blockly.Xml.domToText` will appear on a single line (this is a limitation
+  // of the plain-text format).
+  fieldElement.textContent = this.getValue().replace(/\n/g, '
');
+  return fieldElement;
+};
+
+/**
+ * Sets the field's value based on the given XML element. Should only be
+ * called by Blockly.Xml.
+ * @param {!Element} fieldElement The element containing info about the
+ *    field's state.
+ * @package
+ */
+Blockly.FieldMultilineInput.prototype.fromXml = function(fieldElement) {
+  this.setValue(fieldElement.textContent.replace(/
/g, '\n'));
+};
+
+/**
+ * Create the block UI for this field.
+ * @package
+ */
+Blockly.FieldMultilineInput.prototype.initView = function() {
+  this.createBorderRect_();
+  this.textGroup_ = Blockly.utils.dom.createSvgElement(
+      Blockly.utils.Svg.G, {
+        'class': 'blocklyEditableText',
+      }, this.fieldGroup_);
+};
+
+/**
+ * Get the text from this field as displayed on screen.  May differ from getText
+ * due to ellipsis, and other formatting.
+ * @return {string} Currently displayed text.
+ * @private
+ */
+Blockly.FieldMultilineInput.prototype.getDisplayText_ = function() {
+  var value = this.value_;
+  if (!value) {
+    // Prevent the field from disappearing if empty.
+    return Blockly.Field.NBSP;
+  }
+  var lines = value.split('\n');
+  value = '';
+  for (var i = 0; i < lines.length; i++) {
+    var text = lines[i];
+    if (text.length > this.maxDisplayLength) {
+      // Truncate displayed string and add an ellipsis ('...').
+      text = text.substring(0, this.maxDisplayLength - 4) + '...';
+    }
+    // Replace whitespace with non-breaking spaces so the text doesn't collapse.
+    text = text.replace(/\s/g, Blockly.Field.NBSP);
+
+    value += text;
+    if (i !== lines.length - 1) {
+      value += '\n';
+    }
+  }
+  if (this.sourceBlock_.RTL) {
+    // The SVG is LTR, force value to be RTL.
+    value += '\u200F';
+  }
+  return value;
+};
+
+/**
+ * Updates the text of the textElement.
+ * @protected
+ */
+Blockly.FieldMultilineInput.prototype.render_ = function() {
+  // Remove all text group children.
+  var currentChild;
+  while ((currentChild = this.textGroup_.firstChild)) {
+    this.textGroup_.removeChild(currentChild);
+  }
+
+  // Add in text elements into the group.
+  var lines = this.getDisplayText_().split('\n');
+  var y = 0;
+  for (var i = 0; i < lines.length; i++) {
+    var lineHeight = this.getConstants().FIELD_TEXT_HEIGHT +
+        this.getConstants().FIELD_BORDER_RECT_Y_PADDING;
+    var span = Blockly.utils.dom.createSvgElement(
+        Blockly.utils.Svg.TEXT, {
+          'class': 'blocklyText blocklyMultilineText',
+          x: this.getConstants().FIELD_BORDER_RECT_X_PADDING,
+          y: y + this.getConstants().FIELD_BORDER_RECT_Y_PADDING,
+          dy: this.getConstants().FIELD_TEXT_BASELINE
+        }, this.textGroup_);
+    span.appendChild(document.createTextNode(lines[i]));
+    y += lineHeight;
+  }
+
+  this.updateSize_();
+
+  if (this.isBeingEdited_) {
+    if (this.sourceBlock_.RTL) {
+      // in RTL, we need to let the browser reflow before resizing
+      // in order to get the correct bounding box of the borderRect
+      // avoiding issue #2777.
+      setTimeout(this.resizeEditor_.bind(this), 0);
+    } else {
+      this.resizeEditor_();
+    }
+    var htmlInput = /** @type {!HTMLElement} */(this.htmlInput_);
+    if (!this.isTextValid_) {
+      Blockly.utils.dom.addClass(htmlInput, 'blocklyInvalidInput');
+      Blockly.utils.aria.setState(htmlInput,
+          Blockly.utils.aria.State.INVALID, true);
+    } else {
+      Blockly.utils.dom.removeClass(htmlInput, 'blocklyInvalidInput');
+      Blockly.utils.aria.setState(htmlInput,
+          Blockly.utils.aria.State.INVALID, false);
+    }
+  }
+};
+
+/**
+ * Updates the size of the field based on the text.
+ * @protected
+ */
+Blockly.FieldMultilineInput.prototype.updateSize_ = function() {
+  var nodes = this.textGroup_.childNodes;
+  var totalWidth = 0;
+  var totalHeight = 0;
+  for (var i = 0; i < nodes.length; i++) {
+    var tspan = /** @type {!Element} */ (nodes[i]);
+    var textWidth = Blockly.utils.dom.getTextWidth(tspan);
+    if (textWidth > totalWidth) {
+      totalWidth = textWidth;
+    }
+    totalHeight += this.getConstants().FIELD_TEXT_HEIGHT +
+        (i > 0 ? this.getConstants().FIELD_BORDER_RECT_Y_PADDING : 0);
+  }
+  if (this.borderRect_) {
+    totalHeight += this.getConstants().FIELD_BORDER_RECT_Y_PADDING * 2;
+    totalWidth += this.getConstants().FIELD_BORDER_RECT_X_PADDING * 2;
+    this.borderRect_.setAttribute('width', totalWidth);
+    this.borderRect_.setAttribute('height', totalHeight);
+  }
+  this.size_.width = totalWidth;
+  this.size_.height = totalHeight;
+
+  this.positionBorderRect_();
+};
+
+/**
+ * Create the text input editor widget.
+ * @return {!HTMLTextAreaElement} The newly created text input editor.
+ * @protected
+ */
+Blockly.FieldMultilineInput.prototype.widgetCreate_ = function() {
+  var div = Blockly.WidgetDiv.DIV;
+  var scale = this.workspace_.getScale();
+
+  var htmlInput =
+    /** @type {HTMLTextAreaElement} */ (document.createElement('textarea'));
+  htmlInput.className = 'blocklyHtmlInput blocklyHtmlTextAreaInput';
+  htmlInput.setAttribute('spellcheck', this.spellcheck_);
+  var fontSize = (this.getConstants().FIELD_TEXT_FONTSIZE * scale) + 'pt';
+  div.style.fontSize = fontSize;
+  htmlInput.style.fontSize = fontSize;
+  var borderRadius = (Blockly.FieldTextInput.BORDERRADIUS * scale) + 'px';
+  htmlInput.style.borderRadius = borderRadius;
+  var paddingX = this.getConstants().FIELD_BORDER_RECT_X_PADDING * scale;
+  var paddingY = this.getConstants().FIELD_BORDER_RECT_Y_PADDING * scale / 2;
+  htmlInput.style.padding = paddingY + 'px ' + paddingX + 'px ' + paddingY +
+      'px ' + paddingX + 'px';
+  var lineHeight = this.getConstants().FIELD_TEXT_HEIGHT +
+      this.getConstants().FIELD_BORDER_RECT_Y_PADDING;
+  htmlInput.style.lineHeight = (lineHeight * scale) + 'px';
+
+  div.appendChild(htmlInput);
+
+  htmlInput.value = htmlInput.defaultValue = this.getEditorText_(this.value_);
+  htmlInput.untypedDefaultValue_ = this.value_;
+  htmlInput.oldValue_ = null;
+  if (Blockly.utils.userAgent.GECKO) {
+    // In FF, ensure the browser reflows before resizing to avoid issue #2777.
+    setTimeout(this.resizeEditor_.bind(this), 0);
+  } else {
+    this.resizeEditor_();
+  }
+
+  this.bindInputEvents_(htmlInput);
+
+  return htmlInput;
+};
+
+/**
+ * Handle key down to the editor. Override the text input definition of this
+ * so as to not close the editor when enter is typed in.
+ * @param {!Event} e Keyboard event.
+ * @protected
+ */
+Blockly.FieldMultilineInput.prototype.onHtmlInputKeyDown_ = function(e) {
+  if (e.keyCode !== Blockly.utils.KeyCodes.ENTER) {
+    Blockly.FieldMultilineInput.superClass_.onHtmlInputKeyDown_.call(this, e);
+  }
+};
+
+/**
+ * CSS for multiline field.  See css.js for use.
+ */
+Blockly.Css.register([
+  /* eslint-disable indent */
+  '.blocklyHtmlTextAreaInput {',
+    'font-family: monospace;',
+    'resize: none;',
+    'overflow: hidden;',
+    'height: 100%;',
+    'text-align: left;',
+  '}'
+  /* eslint-enable indent */
+]);
+
+
+Blockly.fieldRegistry.register('field_multilinetext', Blockly.FieldMultilineInput);

package/blocklySkini/blockly/core/field_number.js

@@ -0,0 +1,317 @@
+/**
+ * @license
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Number input field
+ * @author fenichel@google.com (Rachel Fenichel)
+ */
+'use strict';
+
+goog.provide('Blockly.FieldNumber');
+
+goog.require('Blockly.fieldRegistry');
+goog.require('Blockly.FieldTextInput');
+goog.require('Blockly.utils.aria');
+goog.require('Blockly.utils.object');
+
+
+/**
+ * Class for an editable number field.
+ * @param {string|number=} opt_value The initial value of the field. Should cast
+ *    to a number. Defaults to 0.
+ * @param {?(string|number)=} opt_min Minimum value.
+ * @param {?(string|number)=} opt_max Maximum value.
+ * @param {?(string|number)=} opt_precision Precision for value.
+ * @param {?Function=} opt_validator A function that is called to validate
+ *    changes to the field's value. Takes in a number & returns a validated
+ *    number, or null to abort the change.
+ * @param {Object=} opt_config A map of options used to configure the field.
+ *    See the [field creation documentation]{@link https://developers.google.com/blockly/guides/create-custom-blocks/fields/built-in-fields/number#creation}
+ *    for a list of properties this parameter supports.
+ * @extends {Blockly.FieldTextInput}
+ * @constructor
+ */
+Blockly.FieldNumber = function(opt_value, opt_min, opt_max, opt_precision,
+    opt_validator, opt_config) {
+
+  /**
+   * The minimum value this number field can contain.
+   * @type {number}
+   * @protected
+   */
+  this.min_ = -Infinity;
+
+  /**
+   * The maximum value this number field can contain.
+   * @type {number}
+   * @protected
+   */
+  this.max_ = Infinity;
+
+  /**
+   * The multiple to which this fields value is rounded.
+   * @type {number}
+   * @protected
+   */
+  this.precision_ = 0;
+
+  /**
+   * The number of decimal places to allow, or null to allow any number of
+   * decimal digits.
+   * @type {?number}
+   * @private
+   */
+  this.decimalPlaces_ = null;
+
+  Blockly.FieldNumber.superClass_.constructor.call(
+      this, opt_value, opt_validator, opt_config);
+
+  if (!opt_config) {  // Only do one kind of configuration or the other.
+    this.setConstraints(opt_min, opt_max, opt_precision);
+  }
+};
+Blockly.utils.object.inherits(Blockly.FieldNumber, Blockly.FieldTextInput);
+
+/**
+ * The default value for this field.
+ * @type {*}
+ * @protected
+ */
+Blockly.FieldNumber.prototype.DEFAULT_VALUE = 0;
+
+/**
+ * Construct a FieldNumber from a JSON arg object.
+ * @param {!Object} options A JSON object with options (value, min, max, and
+ *                          precision).
+ * @return {!Blockly.FieldNumber} The new field instance.
+ * @package
+ * @nocollapse
+ */
+Blockly.FieldNumber.fromJson = function(options) {
+  return new Blockly.FieldNumber(options['value'],
+      undefined, undefined, undefined, undefined, options);
+};
+
+/**
+ * Serializable fields are saved by the XML renderer, non-serializable fields
+ * are not. Editable fields should also be serializable.
+ * @type {boolean}
+ */
+Blockly.FieldNumber.prototype.SERIALIZABLE = true;
+
+/**
+ * Configure the field based on the given map of options.
+ * @param {!Object} config A map of options to configure the field based on.
+ * @private
+ */
+Blockly.FieldNumber.prototype.configure_ = function(config) {
+  Blockly.FieldNumber.superClass_.configure_.call(this, config);
+  this.setMinInternal_(config['min']);
+  this.setMaxInternal_(config['max']);
+  this.setPrecisionInternal_(config['precision']);
+};
+
+/**
+ * Set the maximum, minimum and precision constraints on this field.
+ * Any of these properties may be undefined or NaN to be disabled.
+ * Setting precision (usually a power of 10) enforces a minimum step between
+ * values. That is, the user's value will rounded to the closest multiple of
+ * precision. The least significant digit place is inferred from the precision.
+ * Integers values can be enforces by choosing an integer precision.
+ * @param {?(number|string|undefined)} min Minimum value.
+ * @param {?(number|string|undefined)} max Maximum value.
+ * @param {?(number|string|undefined)} precision Precision for value.
+ */
+Blockly.FieldNumber.prototype.setConstraints = function(min, max, precision) {
+  this.setMinInternal_(min);
+  this.setMaxInternal_(max);
+  this.setPrecisionInternal_(precision);
+  this.setValue(this.getValue());
+};
+
+/**
+ * Sets the minimum value this field can contain. Updates the value to reflect.
+ * @param {?(number|string|undefined)} min Minimum value.
+ */
+Blockly.FieldNumber.prototype.setMin = function(min) {
+  this.setMinInternal_(min);
+  this.setValue(this.getValue());
+};
+
+/**
+ * Sets the minimum value this field can contain. Called internally to avoid
+ * value updates.
+ * @param {?(number|string|undefined)} min Minimum value.
+ * @private
+ */
+Blockly.FieldNumber.prototype.setMinInternal_ = function(min) {
+  if (min == null) {
+    this.min_ = -Infinity;
+  } else {
+    min = Number(min);
+    if (!isNaN(min)) {
+      this.min_ = min;
+    }
+  }
+};
+
+/**
+ * Returns the current minimum value this field can contain. Default is
+ * -Infinity.
+ * @return {number} The current minimum value this field can contain.
+ */
+Blockly.FieldNumber.prototype.getMin = function() {
+  return this.min_;
+};
+
+/**
+ * Sets the maximum value this field can contain. Updates the value to reflect.
+ * @param {?(number|string|undefined)} max Maximum value.
+ */
+Blockly.FieldNumber.prototype.setMax = function(max) {
+  this.setMaxInternal_(max);
+  this.setValue(this.getValue());
+};
+
+/**
+ * Sets the maximum value this field can contain. Called internally to avoid
+ * value updates.
+ * @param {?(number|string|undefined)} max Maximum value.
+ * @private
+ */
+Blockly.FieldNumber.prototype.setMaxInternal_ = function(max) {
+  if (max == null) {
+    this.max_ = Infinity;
+  } else {
+    max = Number(max);
+    if (!isNaN(max)) {
+      this.max_ = max;
+    }
+  }
+};
+
+/**
+ * Returns the current maximum value this field can contain. Default is
+ * Infinity.
+ * @return {number} The current maximum value this field can contain.
+ */
+Blockly.FieldNumber.prototype.getMax = function() {
+  return this.max_;
+};
+
+/**
+ * Sets the precision of this field's value, i.e. the number to which the
+ * value is rounded. Updates the field to reflect.
+ * @param {?(number|string|undefined)} precision The number to which the
+ *    field's value is rounded.
+ */
+Blockly.FieldNumber.prototype.setPrecision = function(precision) {
+  this.setPrecisionInternal_(precision);
+  this.setValue(this.getValue());
+};
+
+/**
+ * Sets the precision of this field's value. Called internally to avoid
+ * value updates.
+ * @param {?(number|string|undefined)} precision The number to which the
+ *    field's value is rounded.
+ * @private
+ */
+Blockly.FieldNumber.prototype.setPrecisionInternal_ = function(precision) {
+  if (precision == null) {
+    // Number(precision) would also be 0, but set explicitly to be clear.
+    this.precision_ = 0;
+  } else {
+    precision = Number(precision);
+    if (!isNaN(precision)) {
+      this.precision_ = precision;
+    }
+  }
+
+  var precisionString = this.precision_.toLocaleString("en-US", {maximumFractionDigits: 20});
+  var decimalIndex = precisionString.indexOf('.');
+  if (decimalIndex == -1) {
+    // If the precision is 0 (float) allow any number of decimals,
+    // otherwise allow none.
+    this.decimalPlaces_ = precision ? 0 : null;
+  } else {
+    this.decimalPlaces_ = precisionString.length - decimalIndex - 1;
+  }
+};
+
+/**
+ * Returns the current precision of this field. The precision being the
+ * number to which the field's value is rounded. A precision of 0 means that
+ * the value is not rounded.
+ * @return {number} The number to which this field's value is rounded.
+ */
+Blockly.FieldNumber.prototype.getPrecision = function() {
+  return this.precision_;
+};
+
+/**
+ * Ensure that the input value is a valid number (must fulfill the
+ * constraints placed on the field).
+ * @param {*=} opt_newValue The input value.
+ * @return {?number} A valid number, or null if invalid.
+ * @protected
+ * @override
+ */
+Blockly.FieldNumber.prototype.doClassValidation_ = function(opt_newValue) {
+  if (opt_newValue === null) {
+    return null;
+  }
+  // Clean up text.
+  var newValue = String(opt_newValue);
+  // TODO: Handle cases like 'ten', '1.203,14', etc.
+  // 'O' is sometimes mistaken for '0' by inexperienced users.
+  newValue = newValue.replace(/O/ig, '0');
+  // Strip out thousands separators.
+  newValue = newValue.replace(/,/g, '');
+  // Ignore case of 'Infinity'.
+  newValue = newValue.replace(/infinity/i, 'Infinity');
+
+  // Clean up number.
+  var n = Number(newValue || 0);
+  if (isNaN(n)) {
+    // Invalid number.
+    return null;
+  }
+  // Get the value in range.
+  n = Math.min(Math.max(n, this.min_), this.max_);
+  // Round to nearest multiple of precision.
+  if (this.precision_ && isFinite(n)) {
+    n = Math.round(n / this.precision_) * this.precision_;
+  }
+  // Clean up floating point errors.
+  if (this.decimalPlaces_ != null) {
+    n = Number(n.toFixed(this.decimalPlaces_));
+  }
+  return n;
+};
+
+/**
+ * Create the number input editor widget.
+ * @return {!HTMLElement} The newly created number input editor.
+ * @protected
+ * @override
+ */
+Blockly.FieldNumber.prototype.widgetCreate_ = function() {
+  var htmlInput = Blockly.FieldNumber.superClass_.widgetCreate_.call(this);
+
+  // Set the accessibility state
+  if (this.min_ > -Infinity) {
+    Blockly.utils.aria.setState(htmlInput,
+        Blockly.utils.aria.State.VALUEMIN, this.min_);
+  }
+  if (this.max_ < Infinity) {
+    Blockly.utils.aria.setState(htmlInput,
+        Blockly.utils.aria.State.VALUEMAX, this.max_);
+  }
+  return htmlInput;
+};
+
+Blockly.fieldRegistry.register('field_number', Blockly.FieldNumber);

package/blocklySkini/blockly/core/field_registry.js

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Fields can be created based on a JSON definition. This file
+ *    contains methods for registering those JSON definitions, and building the
+ *    fields based on JSON.
+ * @author bekawestberg@gmail.com (Beka Westberg)
+ */
+'use strict';
+
+goog.provide('Blockly.fieldRegistry');
+
+goog.require('Blockly.registry');
+
+goog.requireType('Blockly.IRegistrableField');
+
+
+/**
+ * Registers a field type.
+ * Blockly.fieldRegistry.fromJson uses this registry to
+ * find the appropriate field type.
+ * @param {string} type The field type name as used in the JSON definition.
+ * @param {!Blockly.IRegistrableField} fieldClass The field class containing a
+ *     fromJson function that can construct an instance of the field.
+ * @throws {Error} if the type name is empty, the field is already
+ *     registered, or the fieldClass is not an object containing a fromJson
+ *     function.
+ */
+Blockly.fieldRegistry.register = function(type, fieldClass) {
+  Blockly.registry.register(Blockly.registry.Type.FIELD, type, fieldClass);
+};
+
+/**
+ * Unregisters the field registered with the given type.
+ * @param {string} type The field type name as used in the JSON definition.
+ */
+Blockly.fieldRegistry.unregister = function(type) {
+  Blockly.registry.unregister(Blockly.registry.Type.FIELD, type);
+};
+
+/**
+ * Construct a Field from a JSON arg object.
+ * Finds the appropriate registered field by the type name as registered using
+ * Blockly.fieldRegistry.register.
+ * @param {!Object} options A JSON object with a type and options specific
+ *     to the field type.
+ * @return {Blockly.Field} The new field instance or null if a field wasn't
+ *     found with the given type name
+ * @package
+ */
+Blockly.fieldRegistry.fromJson = function(options) {
+  var fieldObject = /** @type {?Blockly.IRegistrableField} */ (
+    Blockly.registry.getObject(Blockly.registry.Type.FIELD, options['type']));
+  if (!fieldObject) {
+    console.warn('Blockly could not create a field of type ' + options['type'] +
+      '. The field is probably not being registered. This could be because' +
+      ' the file is not loaded, the field does not register itself (Issue' +
+      ' #1584), or the registration is not being reached.');
+    return null;
+  }
+  return fieldObject.fromJson(options);
+};