@lhncbc/ucum-lhc 5.0.4 → 6.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lhncbc/ucum-lhc",
-  "version": "5.0.4",
+  "version": "6.0.1",
   "description": "Implements Unified Code for Units of Measure (UCUM) functions in a javascript library",
   "main": "source-cjs/ucumPkg.js",
   "homepage": "https://lhncbc.github.io/ucum-lhc/",

package/source/config.js

@@ -90,6 +90,24 @@ export var Ucum = {
                        'molecular weight of the substance represented by the ' +
                        'units is required to perform the conversion.',
 
+  /**
+   * Message that is returned when a mass<->eq conversion is requested 
+   * (which requires a molecular weight to calculate), but no molecular 
+   * weight was provided by the user.
+   */                       
+  needEqWeightMsg_ : 'Did you wish to convert with equivalents?  The ' +
+                      'molecular weight of the substance is required to perform ' + 
+                      'the conversion.', 
+
+  /**
+   * Message that is returned when a mass<->eq or a mol<->eq conversion 
+   * is requested (which requires a charge to calculate), but no charge
+   * was provided by the user.
+   */
+  needEqChargeMsg_ : 'Did you wish to convert with equivalents?  The ' +
+                      'charge of the substance is required to perform ' + 
+                      'the conversion.', 
+
   /**
    * Hash that matches unit column names to names used in the csv file
    * that is submitted to the data updater.

package/source/ucumLhcUtils.js

@@ -145,71 +145,143 @@ export class UcumLhcUtils {
   } // end validateUnitString
 
 
+
+/**
+ * @typedef {
+ *   'normal', 
+ *   'mol->mass',
+ *   'mass->mol',
+ *   'eq->mass',
+ *   'mass->eq',
+ *   'eq->mol',
+ *   'mol->eq',
+ * } ConversionType
+ */
+
+  /**
+  * Detects the type of conversion between two units.
+  *
+  * @param {Object} fromUnit - The unit to convert from.
+  * @param {Object} toUnit - The unit to convert to.
+  * @returns {ConversionType} conversionType - The type of conversion as a string.
+  */
+  detectConversionType(fromUnit, toUnit) {
+    /** @type {ConversionType} */
+    let conversionType = 'normal';
+
+    // detect mol <-> mass conversions and eq <-> eq conversions,
+    // and non-mol <-> eq <-> mass conversions
+    if ((fromUnit.isMolarUnit() && toUnit.isMolarUnit()) || 
+        (fromUnit.isEquivalentUnit() && toUnit.isEquivalentUnit()) ||
+        (!(fromUnit.isMolarUnit() || toUnit.isMolarUnit()) && 
+        !(fromUnit.isEquivalentUnit() || toUnit.isEquivalentUnit()))) {
+      conversionType = 'normal';
+    }
+    // handle eq <-> mol/mass conversions
+    else if (fromUnit.isEquivalentUnit()) {
+      conversionType = toUnit.isMolarUnit() ? 'eq->mol' : 'eq->mass';
+    } else if (toUnit.isEquivalentUnit()) {
+      conversionType = fromUnit.isMolarUnit() ? 'mol->eq' : 'mass->eq';
+    }
+    // handle mol <-> mass conversions
+    else if (fromUnit.isMolarUnit()) {
+      conversionType = 'mol->mass';
+    } else if (toUnit.isMolarUnit()) {
+      conversionType = 'mass->mol';
+    }
+
+    return conversionType;
+  } // end detectConversionType
+
+  /** 
+   * @typedef {{
+   *   status: 'succeeded' | 'failed' | 'error',
+   *   toVal: number | null,
+   *   msg: string[],
+   *   suggestions: {
+   *     from: {
+   *       msg: string,
+   *       invalidUnit: string,
+   *       units: string[]
+   *     },
+   *     to: {
+   *       msg: string,
+   *       invalidUnit: string,
+   *       units: string[]
+   *     }
+   *   },
+   *  fromUnit: string,
+   *  toUnit: string
+   * }} ConvertUnitResult
+   */
+
+ 
   /**
    * This method converts one unit to another
    *
-   * @param fromUnitCode the unit code/expression/string of the unit to be converted
-   * @param fromVal the number of "from" units to be converted to "to" units
-   * @param toUnitCode the unit code/expression/string of the unit that the from
-   *  field is to be converted to
-   * @param suggest a boolean to indicate whether or not suggestions are
-   *  requested for a string that cannot be resolved to a valid unit;
-   *  true indicates suggestions are wanted; false indicates they are not,
-   *  and is the default if the parameter is not specified;
-   * @param molecularWeight the molecular weight of the substance in question
-   *  when a conversion is being requested from mass to moles and vice versa.
-   *  This is required when one of the units represents a value in moles.  It is
-   *  ignored if neither unit includes a measurement in moles.
-   * @returns a hash with six elements:
-   *  'status' that will be: 'succeeded' if the conversion was successfully
+   * @param {string} fromUnitCode - the unit code/expression/string of the unit to be converted
+   * @param {number | string} fromVal - the number of "from" units to be converted to "to" units
+   * @param {string} toUnitCode - the unit code/expression/string of the unit that the from field is to be converted to
+   * @param {{
+   *   suggest?: boolean,
+   *   molecularWeight?: number
+   *   charge?: number
+   * }} options
+   *  - suggest: a boolean to indicate whether or not suggestions are requested for a string that cannot be resolved to a valid unit;
+   *    true indicates suggestions are wanted; false indicates they are not, and is the default if the parameter is not specified;
+   *  - molecularWeight: the molecular weight of the substance in question when a conversion is being requested from mass to moles and vice versa.
+   *    This is required when one of the units represents a value in moles.  It is ignored if neither unit includes a measurement in moles.
+   *  - charge: the absolute value of the charge of the substance in question when a conversion is being requested from mass/moles to
+   *    equivalents and vice versa. It is required when one of the units represents a value in equivalents and the other in mass or moles. 
+   *    It is ignored if neither unit includes an equivalent unit.
+   * @returns {ConvertUnitResult}
+   * - a hash with six elements:
+   *   - 'status' that will be: 'succeeded' if the conversion was successfully
    *     calculated; 'failed' if the conversion could not be made, e.g., if
    *     the units are not commensurable; or 'error' if an error occurred;
-   *  'toVal' the numeric value indicating the conversion amount, or null
+   *   - 'toVal' the numeric value indicating the conversion amount, or null
    *     if the conversion failed (e.g., if the units are not commensurable);
-   *  'msg' is an array message, if the string is invalid or an error occurred,
-   *        indicating the problem, or an explanation of a substitution such as
-   *        the substitution of 'G' for 'Gauss', or an empty array if no
-   *        messages were generated;
-   *  'suggestions' if suggestions were requested and found, this is a hash
+   *   - 'msg' is an array message, if the string is invalid or an error occurred,
+   *     indicating the problem, or an explanation of a substitution such as
+   *     the substitution of 'G' for 'Gauss', or an empty array if no
+   *     messages were generated;
+   *   - 'suggestions' if suggestions were requested and found, this is a hash
    *     that contains at most two elements:
-   *     'from' which, if the fromUnitCode input parameter or one or more of
+   *     - 'from' which, if the fromUnitCode input parameter or one or more of
    *       its components could not be found, is an array one or more hash
    *       objects.  Each hash contains three elements:
-   *         'msg' which is a message indicating what unit expression the
-   *            suggestions are for;
-   *         'invalidUnit' which is the unit expression the suggestions
-   *            are for; and
-   *         'units' which is an array of data for each suggested unit found.
-   *            Each array will contain the unit code, the unit name and the
-   *            unit guidance (if any).
+   *       - 'msg' which is a message indicating what unit expression the
+   *          suggestions are for;
+   *       - 'invalidUnit' which is the unit expression the suggestions
+   *          are for; and
+   *       - 'units' which is an array of data for each suggested unit found.
+   *          Each array will contain the unit code, the unit name and the
+   *          unit guidance (if any).
    *       If no suggestions were found for the fromUnitCode this element
    *       will not be included.
-   *     'to' which, if the "to" unit expression or one or more of its
+   *     - 'to' which, if the "to" unit expression or one or more of its
    *       components could not be found, is an array one or more hash objects.  Each hash
    *       contains three elements:
-   *         'msg' which is a message indicating what toUnitCode input
-   *            parameter the suggestions are for;
-   *         'invalidUnit' which is the unit expression the suggestions
-   *            are for; and
-   *         'units' which is an array of data for each suggested unit found.
-   *            Each array will contain the unit code, the unit name and the
-   *            unit guidance (if any).
+   *       - 'msg' which is a message indicating what toUnitCode input
+   *          parameter the suggestions are for;
+   *       - 'invalidUnit' which is the unit expression the suggestions
+   *          are for; and
+   *       - 'units' which is an array of data for each suggested unit found.
+   *          Each array will contain the unit code, the unit name and the
+   *          unit guidance (if any).
    *       If no suggestions were found for the toUnitCode this element
    *       will not be included.
-   *    No 'suggestions' element will be included in the returned hash
-   *    object if none were found, whether or not they were requested.
-   *  'fromUnit' the unit object for the fromUnitCode passed in; returned
+   *       No 'suggestions' element will be included in the returned hash
+   *       object if none were found, whether or not they were requested.
+   *   - 'fromUnit' the unit object for the fromUnitCode passed in; returned
    *     in case it's needed for additional data from the object; and
-   *  'toUnit' the unit object for the toUnitCode passed in; returned
+   *   - 'toUnit' the unit object for the toUnitCode passed in; returned
    *     in case it's needed for additional data from the object.
    */
-  convertUnitTo(fromUnitCode, fromVal, toUnitCode, suggest, molecularWeight) {
-    if (suggest === undefined)
-      suggest = false ;
-
-    if (molecularWeight === undefined)
-      molecularWeight = null ;
+  convertUnitTo(fromUnitCode, fromVal, toUnitCode, options = {}) {
+    let { suggest = false, molecularWeight = null, charge = null } = options;
 
+    /** @type {ConvertUnitResult} */
     let returnObj = {'status' : 'failed',
                      'toVal' : null,
                      'msg' : []} ;
@@ -263,40 +335,53 @@ export class UcumLhcUtils {
 
         if (fromUnit && toUnit) {
           try {
-            // if no molecular weight was specified perform a normal conversion
-            if (!molecularWeight) {
-              returnObj['toVal'] = toUnit.convertFrom(fromVal, fromUnit);
-            }
-            else {
-              if (fromUnit.moleExp_ !== 0 && toUnit.moleExp_ !== 0) {
-                throw(new Error('A molecular weight was specified ' +
-                  'but a mass <-> mole conversion cannot be executed for two ' +
-                  'mole-based units.  No conversion was attempted.'));
-              }
-              if (fromUnit.moleExp_ === 0 && toUnit.moleExp_ === 0) {
-                throw(new Error('A molecular weight was specified ' +
-                  'but a mass <-> mole conversion cannot be executed when ' +
-                  'neither unit is mole-based.  No conversion was attempted.'));
-              }
-              if (!fromUnit.isMoleMassCommensurable(toUnit)) {
-                throw(new Error(`Sorry.  ${fromUnitCode} cannot be ` +
-                  `converted to ${toUnitCode}.`));
-              }
-
-              // if the "from" unit is a mole-based unit, assume a mole to mass
-              // request
-              if (fromUnit.moleExp_ !== 0) {
-                returnObj['toVal'] =
-                  fromUnit.convertMolToMass(fromVal, toUnit, molecularWeight);
-              }
-              // else the "to" unit must be the mole-based unit, so assume a
-              // mass to mole request
-              else {
-                returnObj['toVal'] =
+            const convertType = this.detectConversionType(fromUnit, toUnit); 
+
+            switch (convertType) {
+              case 'normal':
+                returnObj['toVal'] = toUnit.convertFrom(fromVal, fromUnit);
+                break;
+              case 'mol->mass':
+              case 'mass->mol':
+                if (!molecularWeight) {
+                  throw new Error(Ucum.needMoleWeightMsg_);
+                }
+                if (!fromUnit.isMoleMassCommensurable(toUnit)) {
+                  throw new Error(`Sorry.  ${fromUnitCode} cannot be ` +
+                      `converted to ${toUnitCode}.`);
+                }
+                returnObj['toVal'] = convertType === "mol->mass" ?
+                  fromUnit.convertMolToMass(fromVal, toUnit, molecularWeight) :
                   fromUnit.convertMassToMol(fromVal, toUnit, molecularWeight);
-              }
-            } // end if a molecular weight was specified
-
+                break;
+              case 'eq->mass':
+              case 'mass->eq':
+                if (!molecularWeight) {
+                  throw new Error(Ucum.needEqWeightMsg_);
+                }
+                if (!charge) {
+                  throw new Error(Ucum.needEqChargeMsg_);
+                }
+                if (!fromUnit.isEqMassCommensurable(toUnit)) {
+                  throw new Error(`Sorry.  ${fromUnitCode} cannot be ` +
+                      `converted to ${toUnitCode}.`);
+                }
+                returnObj['toVal'] = convertType === "eq->mass" ?
+                  fromUnit.convertEqToMass(fromVal, toUnit, molecularWeight, charge) :
+                  fromUnit.convertMassToEq(fromVal, toUnit, molecularWeight, charge);
+                break;
+              case 'eq->mol':
+              case 'mol->eq':
+                if (!charge) {
+                  throw new Error(Ucum.needEqChargeMsg_);
+                }
+                returnObj['toVal'] = convertType === "eq->mol" ?
+                  fromUnit.convertEqToMol(fromVal, toUnit, charge) :
+                  fromUnit.convertMolToEq(fromVal, toUnit, charge);
+                break;
+              default:
+                throw new Error("Unknown conversion type.  No conversion was attempted.");
+            }
             // if an error hasn't been thrown - either from convertFrom or here,
             // set the return object to show success
             returnObj['status'] = 'succeeded';
@@ -307,10 +392,8 @@ export class UcumLhcUtils {
             returnObj['status'] = 'failed';
             returnObj['msg'].push(err.message);
           }
-
-
-        }  // end if we have the from and to units
-      }
+        } // end if we have the from and to units
+      } 
       catch (err) {
         if (err.message == Ucum.needMoleWeightMsg_)
           returnObj['status'] = 'failed';

package/source/ucumXmlDocument.js

@@ -45,7 +45,11 @@ export class UcumXmlDocument {
     // Creation of unit objects after this file is processed will pick up
     // the moleExp_ value from the base mole unit, but the ones defined in
     // this file will not necessarily do that.
-    this.moleCodes_ = ['mol', 'eq', 'osm', 'kat', 'U' ];
+    this.moleCodes_ = ['mol', 'osm', 'kat', 'U' ];
+    // Works similarly to the moleCodes_ array, but for units that represents
+    // equivalent units. For unit codes in the equivCodes_ array, an equivalentExp_ 
+    // attribute flag will be set to 1. 
+    this.equivCodes_ = ['eq'];
 
     // Make this a singleton.  See UnitTables constructor for details.
 
@@ -231,10 +235,20 @@ export class UcumXmlDocument {
         attrs['class_'] = curUA.attr.class;
       }
       let valNode = curUA.childNamed('value');
+      // Note: This currently works as a boolean flag,
+      // but it should be used to represent the dimensionality
+      // of the unit as an integer instead.
       if (this.moleCodes_.indexOf(curUA.attr.Code) !== -1)
         attrs['moleExp_'] = 1;
       else
         attrs['moleExp_'] = 0;
+      // Adds a flag similar to how moleExp_ works, but for units 
+      // that are equivalent. Note that ideally this should also
+      // take values other than 1 or 0, but for now it is a boolean 
+      // flag.
+      if (this.equivCodes_.indexOf(curUA.attr.Code) !== -1) {
+        attrs['equivalentExp_'] = 1;
+      }
 
 
       // Process special units

package/source/unit.js

@@ -151,6 +151,11 @@ export class Unit {
      */
     this.moleExp_ = attrs['moleExp_'] || 0;
 
+    /**
+     * Flag indicating whether or not this is a equivalent mole unit
+     */
+    this.equivalentExp_ = attrs['equivalentExp_'] || 0;
+
     /*
      * Added when added LOINC list of units
      * synonyms are used by the autocompleter to enhance lookup capabilities
@@ -546,7 +551,7 @@ export class Unit {
     // return the molAmt divided by the molesFactor as the number of moles
     // for the molUnit
     return molAmt/molesFactor ;
-  }
+  } // end convertMassToMol
 
   /**
    * Calculates the number of units that would result from converting a unit
@@ -559,7 +564,7 @@ export class Unit {
    * @param amt the quantity of this unit to be converted
    * @param massUnit the target/to unit for which the converted # is wanted
    * @param molecularWeight the molecular weight of the substance for which the
-   *  conversion is being made
+   * conversion is being made
    * @return the equivalent amount in massUnit
    */
   convertMolToMass(amt, massUnit, molecularWeight) {
@@ -581,9 +586,106 @@ export class Unit {
     // divided by any effects of prefixes applied to the "to" unit, which
     // is assumed to be some form of a gram unit
     return massAmt / massUnit.magnitude_ ;
-  }
+  } // end convertMolToMass
+
+  /**
+   * Converts equivalents to mass.
+   * 
+   * @param {number} equivalents - The amount in equivalents to be converted.
+   * @param {object} targetUnit - The target/to unit for which the converted number is wanted.
+   * @param {number} molecularWeight - The molecular weight of the substance for which the conversion is being made.
+   * @param {number} charge - The absolute value of the charge of the substance for which the conversion is being made.
+   * @returns {number} - The equivalent mass in the specified mass unit.
+   */
+  convertEqToMass(equivalents, targetUnit, molecularWeight, charge) {
+    let standardMoleUnit = this._getUnitTables().getUnitByCode('mol');
+    const molAmount = this.convertEqToMol(equivalents, standardMoleUnit, charge);
+    return this.convertMolToMass(molAmount, targetUnit, molecularWeight);
+  } // end convertEqToMass
+  
+  /**
+   * Converts mass to equivalents.
+   * 
+   * @param {number} mass - The mass to be converted.
+   * @param {object} eqUnit - The target/to unit for which the converted number is wanted.
+   * @param {number} molecularWeight - The molecular weight of the substance for which the conversion is being made.
+   * @param {number} charge - The absolute value of the charge of the substance for which the conversion is being made.
+   * @returns {number} - The equivalent amount in the specified equivalent unit.
+   */
+  convertMassToEq(mass, eqUnit, molecularWeight, charge) {
+    // Calculate equivalent mass by dividing molecular weight by charge
+    let equivalentMass = molecularWeight / charge;
+    // Calculate equivalents by dividing mass by equivalent mass
+    let equivalents = mass / equivalentMass;
+    // Get Avogadro's number from the unit tables
+    let avogadroNumber =  this._getUnitTables().getUnitByCode('mol').magnitude_ ;
+    // Calculate mole factor by dividing the magnitude of the equivalent unit by Avogadro's number
+    // eqUnit may have a prefix (e.g. meq) and we need to adjust for that
+    let moleFactor = eqUnit.magnitude_ / avogadroNumber ;
+    // Adjust equivalents by dividing by the mole factor
+    let adjustedEquivalents = equivalents / moleFactor;
+    // Return the adjusted equivalents
+    return adjustedEquivalents;
+  } // end convertMassToEq
 
+  /**
+   * Checks if the given unit is an equivalent unit.
+   * 
+   * Note: equivalent units are also be molar units, so a unit can return true for 
+   * both isEquivalentUnit and isMolarUnit.
+   * 
+   * @returns {boolean} - Returns true if the unit is an equivalent unit, false otherwise.
+   */
+  isEquivalentUnit() {
+    return this.equivalentExp_ !== 0;
+  } // end isEquivalentUnit
 
+  /**
+   * Checks if the given unit is a molar unit.
+   * 
+   * @returns {boolean} - Returns true if the unit is a molar unit, false otherwise.
+   */
+  isMolarUnit() {
+    return this.moleExp_ !== 0;
+  } // end isMolarUnit
+
+
+  /**
+   * This function converts an equivalent amount to moles using the charge of the substance.
+   * 
+   * @param {number} eqFromVal - The equivalent amount for which the conversion is being made.
+   * @param {object} molToUnit - The target unit for which the converted number is wanted.
+   * @param {number} charge - The absolute value of the charge of the substance for which the conversion is being made.
+   * @return {number} - The amount in moles.
+   */
+  convertEqToMol(eqFromVal, molToUnit, charge){
+    // Check if molToUnit is a molar unit and eqFromVal is a eq unit
+    if (!molToUnit.isMolarUnit() || !this.isEquivalentUnit()){
+      throw new Error("Invalid units for conversion of Eq to Mol. Please provide an equivalent and a molar unit.");
+    }
+    // The conversion from equivalents to moles is based on the principle that one equivalent is equal to 1/valencyFactor moles. 
+    // The relative magnitude is accounted for via the current unit's magnitude (this.magnitude_) and the target unit's magnitude (molToUnit.magnitude_)
+    return eqFromVal * (this.magnitude_ / molToUnit.magnitude_) / charge;
+  } // end convertEqToMol
+
+  /**
+   * This function converts moles to equivalent amount using the charge of the substance.
+   * 
+   * @param {number} molFromVal - The mole amount for which the conversion is being made
+   * @param {object} eqToUnit - The target unit for which the converted number is wanted
+   * @param {number} charge - The absolute value of the charge of the substance for which the conversion is being made
+   * @return {number} - The amount in equivalent
+   */
+  convertMolToEq(molFromVal, eqToUnit, charge){
+    // Check if eqToUnit is an equivalent unit and molFromVal is a molar unit
+    if (!eqToUnit.isEquivalentUnit() || !this.isMolarUnit()){
+      throw new Error("Invalid units for conversion of Mol to Eq. Please provide a molar and an equivalent unit.");
+    }
+    // The conversion from moles to equivalents is based on the principle that one equivalent is equal to 1/valencyFactor moles.
+    // The relative magnitude is accounted for via the current unit's magnitude (this.magnitude_) and the target unit's magnitude (eqToUnit.magnitude_)
+    return molFromVal * charge * (this.magnitude_ / eqToUnit.magnitude_);
+  } // end convertMolToEq
+  
   /**
    * Mutates this unit into a unit on a ratio scale and converts a specified
    * number of units to an appropriate value for this converted unit
@@ -1016,6 +1118,41 @@ export class Unit {
     return commensurable ;
   }
 
+  /**
+   * This function tests this unit against the unit passed in to see if the
+   * two are eq to mass commensurable.  It assumes that one of the units
+   * is a eq-based unit and the other is a mass-based unit.  It also assumes
+   * that the eq-based unit has a single eq unit in the numerator and that
+   * the mass-based unit has a single mass unit in the numerator.  It does NOT
+   * check to validate those assumptions.
+   *
+   * The check is made by setting the dimension vector element corresponding
+   * to the base mass unit (gram) in the eq unit, and then comparing the
+   * two dimension vectors.  If they match, the units are commensurable.
+   * Otherwise they are not.
+   *
+   * @param {Unit} unit2 the unit to be compared to this one
+   * @returns {boolean} boolean indicating commensurability
+   */
+  isEqMassCommensurable(unit2) {
+    let tabs = this._getUnitTables();
+    let d = tabs.getMassDimensionIndex();
+    let commensurable = false ;
+    if (this.equivalentExp_ === 1 && unit2.equivalentExp_ === 0) {
+      let testDim = this.dim_.clone();
+      let curVal = testDim.getElementAt(d);
+      testDim.setElementAt(d, (curVal + this.equivalentExp_));
+      commensurable = (testDim.equals(unit2.dim_));
+    }
+    else if (unit2.equivalentExp_ === 1 && this.equivalentExp_ === 0) {
+      let testDim = unit2.dim_.clone();
+      let curVal = testDim.getElementAt(d);
+      testDim.setElementAt(d, (curVal + unit2.equivalentExp_));
+      commensurable = (testDim.equals(this.dim_));
+    }
+    return commensurable;
+  }
+
 
   /**
    * This returns the UnitTables singleton object.  Including the require

package/source/unitString.js

@@ -1153,10 +1153,17 @@ export class UnitString {
         // Look first for an exponent.  If we got one, separate it out and
         // try to get the unit again
         let codeAndExp = this._isCodeWithExponent(uCode);
+        let isIntegerUnitWithExp = false;
         if (codeAndExp) {
           uCode = codeAndExp[0];
           exp = codeAndExp[1];
-          origUnit = this.utabs_.getUnitByCode(uCode);
+          isIntegerUnitWithExp = intUtils_.isIntegerUnit(uCode);
+          origUnit = isIntegerUnitWithExp ?
+            new Unit({'csCode_' : uCode,
+              'ciCode_' : uCode,
+              'magnitude_' : Number(uCode),
+              'name_' : uCode}) :
+            this.utabs_.getUnitByCode(uCode);
         }
 
         // If an exponent is found but it's not a valid number, e.g. "2-1",
@@ -1294,10 +1301,11 @@ export class UnitString {
             }
             if (exp) {
               let expStr = exp.toString();
+              const intergerUnitExpSign = isIntegerUnitWithExp && exp > 0 ? '+' : '';
               retUnit.assignVals({
                 'name_': theName + '<sup>' + expStr + '</sup>',
-                'csCode_': theCode + expStr,
-                'ciCode_': theCiCode + expStr,
+                'csCode_': theCode + intergerUnitExpSign + expStr,
+                'ciCode_': theCiCode + intergerUnitExpSign + expStr,
                 'printSymbol_': thePrintSymbol + '<sup>' + expStr + '</sup>'
               });
             }

package/source-cjs/config.js

@@ -78,6 +78,18 @@ var Ucum = {
    * but no molecular weight was specified.
    */
   needMoleWeightMsg_: 'Did you wish to convert between mass and moles?  The ' + 'molecular weight of the substance represented by the ' + 'units is required to perform the conversion.',
+  /**
+   * Message that is returned when a mass<->eq conversion is requested 
+   * (which requires a molecular weight to calculate), but no molecular 
+   * weight was provided by the user.
+   */
+  needEqWeightMsg_: 'Did you wish to convert with equivalents?  The ' + 'molecular weight of the substance is required to perform ' + 'the conversion.',
+  /**
+   * Message that is returned when a mass<->eq or a mol<->eq conversion 
+   * is requested (which requires a charge to calculate), but no charge
+   * was provided by the user.
+   */
+  needEqChargeMsg_: 'Did you wish to convert with equivalents?  The ' + 'charge of the substance is required to perform ' + 'the conversion.',
   /**
    * Hash that matches unit column names to names used in the csv file
    * that is submitted to the data updater.

package/source-cjs/config.js.map

@@ -1 +1 @@
-{"version":3,"file":"config.js","names":["Ucum","dimLen_","validOps_","codeSep_","valMsgStart_","valMsgEnd_","cnvMsgStart_","cnvMsgEnd_","openEmph_","closeEmph_","openEmphHTML_","closeEmphHTML_","bracesMsg_","needMoleWeightMsg_","csvCols_","inputKey_","specUnits_","exports"],"sources":["../source/config.js"],"sourcesContent":["/*\n * This defines the namespace for the UCUM classes and provides\n * a place for the definition of global variables and constants.\n *\n * The javascript for this UCUM implementation uses syntax as\n * defined by the ECMAScript 6 standard\n */\n\nexport var Ucum = {\n\n  /**\n   *  Flag indicating whether or not we're using case sensitive labels\n   *  I don't think we need this.  I think we're just going with\n   *  case sensitive, per Clem.   Gunther's code has this flag, but I\n   *  am removing it, at least for now.  lm, 6/2016\n   */\n  //caseSensitive_: true ,\n\n  /**\n   *  The number of elements in a Dimension array.   Currently this\n   *  is set as a configuration variable, but when we get to the point\n   *  of loading the unit definitions from a file, this value will be\n   *  set from that.\n   */\n  dimLen_: 7,\n\n\n  /**\n   *  The characters used as valid operators in a UCUM unit expression,\n   *  where '.' is for multiplication and '/' is for division.\n   */\n  validOps_: ['.', '/'],\n\n\n  /**\n   * The string used to separate a unit code and unit name when they\n   * are displayed together\n   */\n  codeSep_ : ': ',\n\n  // Message text variations for validation methods and conversion methods\n  valMsgStart_ : 'Did you mean ',\n  valMsgEnd_ : '?' ,\n  cnvMsgStart_ : 'We assumed you meant ',\n  cnvMsgEnd_ : '.',\n\n\n/**\n   * Default opening string used to emphasize portions of error messages.\n   * Used when NOT displaying messages on a web site, i.e., for output\n   * from the library methods or to a file.\n   */\n  openEmph_ : ' ->',\n\n  /**\n   * Default closing string used to emphasize portions of error messages.\n   * Used when NOT displaying messages on a web site, i.e., for output\n   * from the library methods or to a file.\n   */\n  closeEmph_ : '<- ' ,\n\n  /**\n   * Opening HTML used to emphasize portions of error messages.  Used when\n   * displaying messages on a web site; should be blank when output is\n   * to a file.\n   */\n  openEmphHTML_ : ' <span class=\"emphSpan\">',\n\n  /**\n   * Closing HTML used to emphasize portions of error messages.  Used when\n   * displaying messages on a web site; should be blank when output is\n   * to a file.\n   */\n  closeEmphHTML_ : '</span> ' ,\n\n  /**\n   * Message that is displayed when annotations are included in a unit\n   * string, to let the user know how they are interpreted.\n   */\n  bracesMsg_ : 'FYI - annotations (text in curly braces {}) are ignored, ' +\n               'except that an annotation without a leading symbol implies ' +\n               'the default unit 1 (the unity).',\n\n  /**\n   * Message that is displayed or returned when a conversion is requested\n   * for two units where (only) a mass<->moles conversion is appropriate\n   * but no molecular weight was specified.\n   */\n  needMoleWeightMsg_ : 'Did you wish to convert between mass and moles?  The ' +\n                       'molecular weight of the substance represented by the ' +\n                       'units is required to perform the conversion.',\n\n  /**\n   * Hash that matches unit column names to names used in the csv file\n   * that is submitted to the data updater.\n   */\n  csvCols_ : {\n    'case-sensitive code' : 'csCode_',\n    'LOINC property' : 'loincProperty_',\n    'name (display)' : 'name_',\n    'synonyms' : 'synonyms_',\n    'source' : 'source_',\n    'category' : 'category_',\n    'Guidance' : 'guidance_'\n  } ,\n\n  /**\n   * Name of the column in the csv file that serves as the key\n   */\n  inputKey_ : 'case-sensitive code' ,\n\n  /**\n   * Special codes that contain operators within brackets.  The operator\n   * within these codes causes them to parse incorrectly if they are preceded\n   * by a prefix, because the parsing algorithm splits them up on the operator.\n   * So we use this object to identify them and substitute placeholders to\n   * avoid that.\n   */\n   specUnits_ : { 'B[10.nV]' : 'specialUnitOne',\n                  '[m/s2/Hz^(1/2)]' : 'specialUnitTwo'}\n} ;\n\n\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEO,IAAIA,IAAI,GAAG;EAEhB;AACF;AACA;AACA;AACA;AACA;EACE;;EAEA;AACF;AACA;AACA;AACA;AACA;EACEC,OAAO,EAAE,CAAC;EAGV;AACF;AACA;AACA;EACEC,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC;EAGrB;AACF;AACA;AACA;EACEC,QAAQ,EAAG,IAAI;EAEf;EACAC,YAAY,EAAG,eAAe;EAC9BC,UAAU,EAAG,GAAG;EAChBC,YAAY,EAAG,uBAAuB;EACtCC,UAAU,EAAG,GAAG;EAGlB;AACA;AACA;AACA;AACA;EACEC,SAAS,EAAG,KAAK;EAEjB;AACF;AACA;AACA;AACA;EACEC,UAAU,EAAG,KAAK;EAElB;AACF;AACA;AACA;AACA;EACEC,aAAa,EAAG,0BAA0B;EAE1C;AACF;AACA;AACA;AACA;EACEC,cAAc,EAAG,UAAU;EAE3B;AACF;AACA;AACA;EACEC,UAAU,EAAG,2DAA2D,GAC3D,6DAA6D,GAC7D,iCAAiC;EAE9C;AACF;AACA;AACA;AACA;EACEC,kBAAkB,EAAG,uDAAuD,GACvD,uDAAuD,GACvD,8CAA8C;EAEnE;AACF;AACA;AACA;EACEC,QAAQ,EAAG;IACT,qBAAqB,EAAG,SAAS;IACjC,gBAAgB,EAAG,gBAAgB;IACnC,gBAAgB,EAAG,OAAO;IAC1B,UAAU,EAAG,WAAW;IACxB,QAAQ,EAAG,SAAS;IACpB,UAAU,EAAG,WAAW;IACxB,UAAU,EAAG;EACf,CAAC;EAED;AACF;AACA;EACEC,SAAS,EAAG,qBAAqB;EAEjC;AACF;AACA;AACA;AACA;AACA;AACA;EACGC,UAAU,EAAG;IAAE,UAAU,EAAG,gBAAgB;IAC7B,iBAAiB,EAAG;EAAgB;AACtD,CAAC;AAAEC,OAAA,CAAAjB,IAAA,GAAAA,IAAA"}
+{"version":3,"file":"config.js","names":["Ucum","dimLen_","validOps_","codeSep_","valMsgStart_","valMsgEnd_","cnvMsgStart_","cnvMsgEnd_","openEmph_","closeEmph_","openEmphHTML_","closeEmphHTML_","bracesMsg_","needMoleWeightMsg_","needEqWeightMsg_","needEqChargeMsg_","csvCols_","inputKey_","specUnits_","exports"],"sources":["../source/config.js"],"sourcesContent":["/*\n * This defines the namespace for the UCUM classes and provides\n * a place for the definition of global variables and constants.\n *\n * The javascript for this UCUM implementation uses syntax as\n * defined by the ECMAScript 6 standard\n */\n\nexport var Ucum = {\n\n  /**\n   *  Flag indicating whether or not we're using case sensitive labels\n   *  I don't think we need this.  I think we're just going with\n   *  case sensitive, per Clem.   Gunther's code has this flag, but I\n   *  am removing it, at least for now.  lm, 6/2016\n   */\n  //caseSensitive_: true ,\n\n  /**\n   *  The number of elements in a Dimension array.   Currently this\n   *  is set as a configuration variable, but when we get to the point\n   *  of loading the unit definitions from a file, this value will be\n   *  set from that.\n   */\n  dimLen_: 7,\n\n\n  /**\n   *  The characters used as valid operators in a UCUM unit expression,\n   *  where '.' is for multiplication and '/' is for division.\n   */\n  validOps_: ['.', '/'],\n\n\n  /**\n   * The string used to separate a unit code and unit name when they\n   * are displayed together\n   */\n  codeSep_ : ': ',\n\n  // Message text variations for validation methods and conversion methods\n  valMsgStart_ : 'Did you mean ',\n  valMsgEnd_ : '?' ,\n  cnvMsgStart_ : 'We assumed you meant ',\n  cnvMsgEnd_ : '.',\n\n\n/**\n   * Default opening string used to emphasize portions of error messages.\n   * Used when NOT displaying messages on a web site, i.e., for output\n   * from the library methods or to a file.\n   */\n  openEmph_ : ' ->',\n\n  /**\n   * Default closing string used to emphasize portions of error messages.\n   * Used when NOT displaying messages on a web site, i.e., for output\n   * from the library methods or to a file.\n   */\n  closeEmph_ : '<- ' ,\n\n  /**\n   * Opening HTML used to emphasize portions of error messages.  Used when\n   * displaying messages on a web site; should be blank when output is\n   * to a file.\n   */\n  openEmphHTML_ : ' <span class=\"emphSpan\">',\n\n  /**\n   * Closing HTML used to emphasize portions of error messages.  Used when\n   * displaying messages on a web site; should be blank when output is\n   * to a file.\n   */\n  closeEmphHTML_ : '</span> ' ,\n\n  /**\n   * Message that is displayed when annotations are included in a unit\n   * string, to let the user know how they are interpreted.\n   */\n  bracesMsg_ : 'FYI - annotations (text in curly braces {}) are ignored, ' +\n               'except that an annotation without a leading symbol implies ' +\n               'the default unit 1 (the unity).',\n\n  /**\n   * Message that is displayed or returned when a conversion is requested\n   * for two units where (only) a mass<->moles conversion is appropriate\n   * but no molecular weight was specified.\n   */\n  needMoleWeightMsg_ : 'Did you wish to convert between mass and moles?  The ' +\n                       'molecular weight of the substance represented by the ' +\n                       'units is required to perform the conversion.',\n\n  /**\n   * Message that is returned when a mass<->eq conversion is requested \n   * (which requires a molecular weight to calculate), but no molecular \n   * weight was provided by the user.\n   */                       \n  needEqWeightMsg_ : 'Did you wish to convert with equivalents?  The ' +\n                      'molecular weight of the substance is required to perform ' + \n                      'the conversion.', \n\n  /**\n   * Message that is returned when a mass<->eq or a mol<->eq conversion \n   * is requested (which requires a charge to calculate), but no charge\n   * was provided by the user.\n   */\n  needEqChargeMsg_ : 'Did you wish to convert with equivalents?  The ' +\n                      'charge of the substance is required to perform ' + \n                      'the conversion.', \n\n  /**\n   * Hash that matches unit column names to names used in the csv file\n   * that is submitted to the data updater.\n   */\n  csvCols_ : {\n    'case-sensitive code' : 'csCode_',\n    'LOINC property' : 'loincProperty_',\n    'name (display)' : 'name_',\n    'synonyms' : 'synonyms_',\n    'source' : 'source_',\n    'category' : 'category_',\n    'Guidance' : 'guidance_'\n  } ,\n\n  /**\n   * Name of the column in the csv file that serves as the key\n   */\n  inputKey_ : 'case-sensitive code' ,\n\n  /**\n   * Special codes that contain operators within brackets.  The operator\n   * within these codes causes them to parse incorrectly if they are preceded\n   * by a prefix, because the parsing algorithm splits them up on the operator.\n   * So we use this object to identify them and substitute placeholders to\n   * avoid that.\n   */\n   specUnits_ : { 'B[10.nV]' : 'specialUnitOne',\n                  '[m/s2/Hz^(1/2)]' : 'specialUnitTwo'}\n} ;\n\n\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEO,IAAIA,IAAI,GAAG;EAEhB;AACF;AACA;AACA;AACA;AACA;EACE;;EAEA;AACF;AACA;AACA;AACA;AACA;EACEC,OAAO,EAAE,CAAC;EAGV;AACF;AACA;AACA;EACEC,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC;EAGrB;AACF;AACA;AACA;EACEC,QAAQ,EAAG,IAAI;EAEf;EACAC,YAAY,EAAG,eAAe;EAC9BC,UAAU,EAAG,GAAG;EAChBC,YAAY,EAAG,uBAAuB;EACtCC,UAAU,EAAG,GAAG;EAGlB;AACA;AACA;AACA;AACA;EACEC,SAAS,EAAG,KAAK;EAEjB;AACF;AACA;AACA;AACA;EACEC,UAAU,EAAG,KAAK;EAElB;AACF;AACA;AACA;AACA;EACEC,aAAa,EAAG,0BAA0B;EAE1C;AACF;AACA;AACA;AACA;EACEC,cAAc,EAAG,UAAU;EAE3B;AACF;AACA;AACA;EACEC,UAAU,EAAG,2DAA2D,GAC3D,6DAA6D,GAC7D,iCAAiC;EAE9C;AACF;AACA;AACA;AACA;EACEC,kBAAkB,EAAG,uDAAuD,GACvD,uDAAuD,GACvD,8CAA8C;EAEnE;AACF;AACA;AACA;AACA;EACEC,gBAAgB,EAAG,iDAAiD,GAChD,2DAA2D,GAC3D,iBAAiB;EAErC;AACF;AACA;AACA;AACA;EACEC,gBAAgB,EAAG,iDAAiD,GAChD,iDAAiD,GACjD,iBAAiB;EAErC;AACF;AACA;AACA;EACEC,QAAQ,EAAG;IACT,qBAAqB,EAAG,SAAS;IACjC,gBAAgB,EAAG,gBAAgB;IACnC,gBAAgB,EAAG,OAAO;IAC1B,UAAU,EAAG,WAAW;IACxB,QAAQ,EAAG,SAAS;IACpB,UAAU,EAAG,WAAW;IACxB,UAAU,EAAG;EACf,CAAC;EAED;AACF;AACA;EACEC,SAAS,EAAG,qBAAqB;EAEjC;AACF;AACA;AACA;AACA;AACA;AACA;EACGC,UAAU,EAAG;IAAE,UAAU,EAAG,gBAAgB;IAC7B,iBAAiB,EAAG;EAAgB;AACtD,CAAC;AAAEC,OAAA,CAAAnB,IAAA,GAAAA,IAAA"}