Change typeName function to member variable with accessor.

Author: carlosperate

blockly/core/type.js

@@ -16,15 +16,16 @@ goog.require('goog.asserts');
 
 /**
  * Blockly Type class constructor.
- * @param {Object} args Object/dictionary with typeId, and compatibleTypes.
+ * @param {Object} args Object/dictionary with typeId, typeNameMsgId, and
+ *     compatibleTypes.
  * @constructor
  */
 Blockly.Type = function(args) {
-  if ((args.typeId === undefined) || (args.typeName === undefined) || 
+  if ((args.typeId === undefined) || (args.typeNameMsgId === undefined) ||
       (args.compatibleTypes === undefined)) {
     throw new Error('Creating a Type requires the following format:\n{\n' +
                     '  typeId: string,\n' +
-                    '  typeName: function returning a string,\n' +
+                    '  typeNameMsgId: Blockly.Msg string member name,\n' +
                     '  compatibleTypes: [Blockly.Type,]\n}');
   }
   if (!goog.isArray(args.compatibleTypes)) {
@@ -33,11 +34,11 @@ Blockly.Type = function(args) {
   }
   /** @type {string} */
   this.typeId = args.typeId;
-  /** @type {function} 
-      This is the translatable name. As translation is only present past build, 
-      pass a function to return translated string.
-    */
-  this.typeName = args.typeName;
+  /** @type {string}
+   * This is the translatable Blockly.Msg member string name.
+   * @private
+   */
+  this.typeNameStrId_ = args.typeNameMsgId;
   /**
    * @type {Array<Blockly.Type>} 
    * @private
@@ -52,6 +53,16 @@ Blockly.Type = function(args) {
   this.generateCheckList_();
 };
 
+/** Getter for the typeName property, used for translatable Type naming. */
+Object.defineProperty(Blockly.Type.prototype, 'typeName', {
+  get: function() {
+    return Blockly.Msg[this.typeNameStrId_] || this.typeId;
+  },
+  set: function(value) {
+    console.warn('"Blockly.Type" property "typeName" is not allowed to be set.');
+  }
+});
+
 /** Getter for the output property, used for block output types. */
 Object.defineProperty(Blockly.Type.prototype, 'output', {
   get: function() {

blockly/core/types.js

@@ -16,49 +16,49 @@ goog.require('Blockly.Type');
 /** Single character. */
 Blockly.Types.CHARACTER = new Blockly.Type({
   typeId: 'Character',
-  typeName: function() {return Blockly.Msg.ARD_TYPE_CHAR;},
+  typeNameMsgId: 'ARD_TYPE_CHAR',
   compatibleTypes: []
 });
 
 /** Text string. */
 Blockly.Types.TEXT = new Blockly.Type({
   typeId: 'Text',
-  typeName: function() {return Blockly.Msg.ARD_TYPE_TEXT;},
+  typeNameMsgId: 'ARD_TYPE_TEXT',
   compatibleTypes: [Blockly.Types.CHARACTER]
 });
 
 /** Boolean. */
 Blockly.Types.BOOLEAN = new Blockly.Type({
   typeId: 'Boolean',
-  typeName: function() {return Blockly.Msg.ARD_TYPE_BOOL;},
+  typeNameMsgId: 'ARD_TYPE_BOOL',
   compatibleTypes: []
 });
 
 /** Short integer number. */
 Blockly.Types.SHORT_NUMBER = new Blockly.Type({
   typeId: 'Short Positive Number',
-  typeName: function() {return Blockly.Msg.ARD_TYPE_SHORTPOS;},
+  typeNameMsgId: 'ARD_TYPE_SHORTPOS',
   compatibleTypes: []    // Circular dependencies, add after all declarations
 });
 
 /** Integer number. */
 Blockly.Types.NUMBER = new Blockly.Type({
   typeId: 'Number',
-  typeName: function() {return Blockly.Msg.ARD_TYPE_NUMBER;},
+  typeNameMsgId: 'ARD_TYPE_NUMBER',
   compatibleTypes: []    // Circular dependencies, add after all declarations
 });
 
 /** Large integer number. */
 Blockly.Types.LARGE_NUMBER = new Blockly.Type({
   typeId: 'Large Number',
-  typeName: function() {return Blockly.Msg.ARD_TYPE_LONG;},
+  typeNameMsgId: 'ARD_TYPE_LONG',
   compatibleTypes: []    // Circular dependencies, add after all declarations
 });
 
 /** Decimal/floating point number. */
 Blockly.Types.DECIMAL = new Blockly.Type({
   typeId: 'Decimal',
-  typeName: function() {return Blockly.Msg.ARD_TYPE_DECIMAL;},
+  typeNameMsgId: 'ARD_TYPE_DECIMAL',
   compatibleTypes: [Blockly.Types.BOOLEAN,
                     Blockly.Types.SHORT_NUMBER,
                     Blockly.Types.NUMBER,
@@ -68,28 +68,28 @@ Blockly.Types.DECIMAL = new Blockly.Type({
 /** Array/List of items. */
 Blockly.Types.ARRAY = new Blockly.Type({
   typeId: 'Array',
-  typeName: function() {return Blockly.Msg.ARD_TYPE_ARRAY},
+  typeNameMsgId: 'ARD_TYPE_ARRAY',
   compatibleTypes: []
 });
 
 /** Null indicate there is no type. */
 Blockly.Types.NULL = new Blockly.Type({
   typeId: 'Null',
-  typeName: function() {return Blockly.Msg.ARD_TYPE_NULL;},
+  typeNameMsgId: 'ARD_TYPE_NULL',
   compatibleTypes: []
 });
 
 /** Type not defined, or not yet defined. */
 Blockly.Types.UNDEF = new Blockly.Type({
   typeId: 'Undefined',
-  typeName: function() {return Blockly.Msg.ARD_TYPE_UNDEF;},
+  typeNameMsgId: 'ARD_TYPE_UNDEF',
   compatibleTypes: []
 });
 
 /** Set when no child block (meant to define the variable type) is connected. */
 Blockly.Types.CHILD_BLOCK_MISSING = new Blockly.Type({
   typeId: 'ChildBlockMissing',
-  typeName: function() {return Blockly.Msg.ARD_TYPE_CHILDBLOCKMISSING;},
+  typeNameMsgId: 'ARD_TYPE_CHILDBLOCKMISSING',
   compatibleTypes: []
 });
 
@@ -119,19 +119,20 @@ Blockly.Types.LARGE_NUMBER.addCompatibleTypes([
 /**
  * Adds another type to the Blockly.Types collection.
  * @param {string} typeId_ Identifiable name of the type.
- * @param {string} typeName_ Descriptive name of the type for use in the UI.
+ * @param {string} typeNameMsgId_ Name of the member variable from Blockly.Msg
+ *     object to identify the translateble string.for the Type name.
  * @param {Array<Blockly.Type>} compatibleTypes_ List of types this Type is
  *     compatible with.
  */
-Blockly.Types.addType = function(typeId_, typeName_, compatibleTypes_) {
+Blockly.Types.addType = function(typeId_, typeNameMsgId_, compatibleTypes_) {
   // The Id is used as the key from the value pair in the BlocklyTypes object
   var key = typeId_.toUpperCase().replace(/ /g, '_');
   if (Blockly.Types[key] !== undefined) {
     throw 'The Blockly type ' + key + ' already exists.';
   }
   Blockly.Types[key] = new Blockly.Type({
     typeId: typeId_,
-    typeName: function() {return typeName_;},
+    typeName: typeNameMsgId_,
     compatibleTypes: compatibleTypes_
   });
 };
@@ -148,7 +149,7 @@ Blockly.Types.getValidTypeArray = function() {
         (typeKey !== 'NULL') && (typeKey !== 'ARRAY') &&
         (typeof Blockly.Types[typeKey] !== 'function') &&
         !(Blockly.Types[typeKey] instanceof RegExp)) {
-      typesArray.push([Blockly.Types[typeKey].typeName(), typeKey]);
+      typesArray.push([Blockly.Types[typeKey].typeName, typeKey]);
     }
   }
   return typesArray;