polymer-unit-convert.html

<link rel="import" href="../polymer/polymer.html">
<link rel="import" href="../polymer-unit-prefix/polymer-unit-prefix.html">

<dom-module id="unit-convert">
  <template>
    <content></content>
  </template>
</dom-module>
<script>

(function() {

  var unitMap = {

    "meter": {
      "yard": 1 / 0.9144,
      "mile": 1 / 0.9144 / 1760,
      "nautical_mile": 1 / 1852
    }

  };

  var abbreviations = {
    'km': 'kilometer',
    'm': 'meter',
    'kt': 'knots',
    'h': 'hour',
    'min': 'minute',
    's': 'second',
    'sec': 'second',
    'n.m.': 'nautical_mile',
    'yd.': 'yard'
  };

  var unitPrefixElement = document.createElement('unit-prefix');
  
  Polymer({

    is: 'unit-convert',

    properties: {
      from: {
        type: String,
        notify: true
      },
      to: {
        type: String,
        notify: true
      },
      value: {
        type: Number,
        notify: true
      },
      normalizedValue: {
        type: Number,
        notify: true,
        readOnly: true
      },
      result: {
        type: Number,
        readOnly: true
      },
      decimals: {
        type: Number,
        value: null,
        notify: true
      }
    },

    ready: function() {
      this.addEventListener('from-changed', this.update);
      this.addEventListener('to-changed', this.update);
      this.addEventListener('value-changed', this.update);
      this.addEventListener('decimals-changed', this.update);
      this.update();
    },

    update: function() {

      var result = this.calculate(this.from, this.to, this.value);

      if(isDefined(this.decimals)) {
        result = parseFloat(result).toFixed(this.decimals);
      }

      this._setResult(parseFloat(result));

    },

    resolveAbbreviation: function(unit) {
      if(abbreviations.hasOwnProperty(unit)) {
        return abbreviations[unit];
      } else {
        return unit;
      }
    },

    calculate: function(from, to, value, bePrecise) {

      if(from === to) {
        return value;
      }

      from = this.resolveAbbreviation(isDefined(from) ? from : this.from);
      to = this.resolveAbbreviation(isDefined(to) ? to : this.to);
      value = isDefined(value) ? value : this.value;
      bePrecise = !!bePrecise;

      if(areDefined([ from, to, value ])) {

        var fromBaseUnit = this.getBaseUnit(from),
            toBaseUnit = this.getBaseUnit(to),
            commonBaseUnit = this.findCommonMapParent(fromBaseUnit, toBaseUnit);

        value = unitPrefixElement.normalize(value, from);        
        value *= this.getUnitMapping(fromBaseUnit, commonBaseUnit);
        value *= this.getUnitMapping(commonBaseUnit, toBaseUnit);

        result = unitPrefixElement.denormalize(value, to);

        if(!bePrecise) {
          return parseFloat(result.toPrecision(12));
        } else {
          return result;
        }

      }

      return undefined;

    },

    findCommonMapParent: function(fromBaseUnit, toBaseUnit) {

      var i,j;

      var fromParent, toParent;

      for(i in unitMap) {
        if(unitMap.hasOwnProperty(i)) {

          for(j in unitMap[i]) {
            if(unitMap[i].hasOwnProperty(j)) {

              if(i === fromBaseUnit || j === fromBaseUnit) {
                fromParent = i;
              }

              if(i === toBaseUnit || j === toBaseUnit) {
                toParent = i;
              }

            }
          }

          if(fromParent === toParent) {
            return fromParent;
          }

        }
      }

      return undefined;

    },

    getBaseUnit: function(unit) {
      return unitPrefixElement.getBaseUnit(unit);
    },

    baseUnitMatches: function(baseUnit, unit) {

      if(baseUnit === unit) {
        return true
      } else if (baseUnit.length === unit.length) {
        return false;
      } else if(unit.indexOf(baseUnit) !== -1) {
        return (unit.indexOf(baseUnit) + baseUnit.length) === unit.length;
      }

      return false;

    },

    getUnitMapping: function(fromBaseUnit, toBaseUnit) {

      if(fromBaseUnit === toBaseUnit) {
        return 1;
      }

      var i,j;
      for(i in unitMap) {
        if(unitMap.hasOwnProperty(i)) {

          for(j in unitMap[i]) {
            if(unitMap[i].hasOwnProperty(j)) {

              if((j === fromBaseUnit) && (i === toBaseUnit)) {
                return 1 / unitMap[i][j];
              } else if((i === fromBaseUnit) && (j === toBaseUnit)) {
                return unitMap[i][j];
              }

            }
          }

        }
      }

      return 1;

    }

  });

  function areDefined (arr) {

    var self = this,
        allValuesAreDefined = true;

    arr.forEach(function(value) {
      if(!isDefined(value)) {
        allValuesAreDefined = false;
      }
    });

    return allValuesAreDefined;

  }

  function isDefined (value) {
    return (value !== undefined) && (value !== null);
  }

})();

</script>