@cdc/core 4.23.5 → 4.23.7

package/helpers/DataTransform.js

@@ -11,109 +11,109 @@ export class DataTransform {
 
   //Performs standardizations that can be completed automatically without use input
   autoStandardize(data) {
-    const errorsFound = [];
+    const errorsFound = []
 
     // Empty data
     if (0 === data.length) {
-      errorsFound.push(this.constants.errorMessageEmptyData);
+      errorsFound.push(this.constants.errorMessageEmptyData)
     }
 
     // Does it have the correct data structure?
     if (!data.filter || data.filter(row => typeof row !== 'object').length > 0) {
-      errorsFound.push(this.constants.errorMessageFormat);
+      errorsFound.push(this.constants.errorMessageFormat)
     }
 
     if (errorsFound.length > 0) {
-      console.error(errorsFound);
-      return undefined;
+      console.error(errorsFound)
+      return undefined
     }
 
     //Convert array of arrays, to array of objects
     if (data.filter(row => row.constructor !== Object).length > 0) {
-      let standardizedData = [];
+      let standardizedData = []
       for (let row = 1; row < data.length; row++) {
-        let standardizedRow = {};
+        let standardizedRow = {}
         data[row].forEach((datum, col) => {
-          standardizedRow[data[0][col]] = datum;
+          standardizedRow[data[0][col]] = datum
         })
-        standardizedData.push(standardizedRow);
+        standardizedData.push(standardizedRow)
       }
-      data = standardizedData;
+      data = standardizedData
     }
 
-    return data;
+    return data
   }
 
   //Performs standardizations based on developer provided description of the data
   developerStandardize(data, description) {
     //Validate the description object
     if (!description) {
-      return undefined;
+      return undefined
     }
 
     if (description.horizontal === undefined || description.series === undefined) {
-      return undefined;
+      return undefined
     }
 
     if (description.series === true && description.horizontal === false && description.singleRow === undefined) {
-      return undefined;
+      return undefined
     }
 
     if (description.horizontal === true) {
       if (description.series === true) {
         if (!description.seriesKey) {
-          return undefined;
+          return undefined
         }
 
-        let standardizedMapped = {};
-        let standardized = [];
+        let standardizedMapped = {}
+        let standardized = []
         data.forEach(row => {
-          let nonNumericKeys = [];
+          let nonNumericKeys = []
           Object.keys(row).forEach(key => {
             if (key !== description.seriesKey && isNaN(parseFloat(row[key]))) {
-              nonNumericKeys.push(key);
+              nonNumericKeys.push(key)
             }
           })
 
           Object.keys(row).forEach(key => {
             if (key !== description.seriesKey && nonNumericKeys.indexOf(key) === -1) {
-              let uniqueKey = key + '|' + nonNumericKeys.map(nonNumericKey => nonNumericKey + '=' + row[nonNumericKey]);
+              let uniqueKey = key + '|' + nonNumericKeys.map(nonNumericKey => nonNumericKey + '=' + row[nonNumericKey])
               if (!standardizedMapped[uniqueKey]) {
-                standardizedMapped[uniqueKey] = { [row[description.seriesKey]]: row[key], key };
+                standardizedMapped[uniqueKey] = { [row[description.seriesKey]]: row[key], key }
                 nonNumericKeys.forEach(nonNumericKey => {
-                  standardizedMapped[uniqueKey][nonNumericKey] = row[nonNumericKey];
+                  standardizedMapped[uniqueKey][nonNumericKey] = row[nonNumericKey]
                 })
               }
-              standardizedMapped[uniqueKey][row[description.seriesKey]] = row[key];
+              standardizedMapped[uniqueKey][row[description.seriesKey]] = row[key]
             }
           })
         })
 
         Object.keys(standardizedMapped).forEach(key => {
-          standardized.push(standardizedMapped[key]);
+          standardized.push(standardizedMapped[key])
         })
 
-        return standardized;
+        return standardized
       } else {
-        let standardized = [];
+        let standardized = []
 
         data.forEach(row => {
-          let nonNumericKeys = [];
+          let nonNumericKeys = []
           Object.keys(row).forEach(key => {
             if (isNaN(parseFloat(row[key]))) {
-              nonNumericKeys.push(key);
+              nonNumericKeys.push(key)
             }
           })
 
           Object.keys(row).forEach(key => {
             if (nonNumericKeys.indexOf(key) === -1) {
-              let newRow = { key, value: row[key] };
+              let newRow = { key, value: row[key] }
 
               nonNumericKeys.forEach(nonNumericKey => {
-                newRow[nonNumericKey] = row[nonNumericKey];
+                newRow[nonNumericKey] = row[nonNumericKey]
               })
 
-              standardized.push(newRow);
+              standardized.push(newRow)
             }
           })
         })
@@ -122,43 +122,43 @@ export class DataTransform {
       }
     } else if (description.series === true && description.singleRow === false) {
       if (description.seriesKey !== undefined && description.xKey !== undefined && (description.valueKey !== undefined || (description.valueKeys !== undefined && description.valueKeys.length > 0))) {
-        if(description.valueKeys !== undefined){
-          let standardizedMapped = {};
-          let standardized = [];
-          let valueKeys = description.valueKeys;
-          if(description.ignoredKeys && description.ignoredKeys.length > 0){
-            valueKeys = valueKeys.concat(description.ignoredKeys);
+        if (description.valueKeys !== undefined) {
+          let standardizedMapped = {}
+          let standardized = []
+          let valueKeys = description.valueKeys
+          if (description.ignoredKeys && description.ignoredKeys.length > 0) {
+            valueKeys = valueKeys.concat(description.ignoredKeys)
           }
 
           data.forEach(row => {
             valueKeys.forEach(valueKey => {
-              let extraKeys = [];
-              let uniqueKey = row[description.xKey] + '|' + valueKey;
+              let extraKeys = []
+              let uniqueKey = row[description.xKey] + '|' + valueKey
               Object.keys(row).forEach(key => {
                 if (key !== description.xKey && key !== description.seriesKey && valueKeys.indexOf(key) === -1) {
-                  uniqueKey += '|' + key + '=' + row[key];
-                  extraKeys.push(key);
+                  uniqueKey += '|' + key + '=' + row[key]
+                  extraKeys.push(key)
                 }
               })
 
-              if(!standardizedMapped[uniqueKey]){ 
-                standardizedMapped[uniqueKey] = { [description.xKey]: row[description.xKey], '**Numeric Value Property**': valueKey };
+              if (!standardizedMapped[uniqueKey]) {
+                standardizedMapped[uniqueKey] = { [description.xKey]: row[description.xKey], '**Numeric Value Property**': valueKey }
                 extraKeys.forEach(key => {
-                  standardizedMapped[uniqueKey][key] = row[key];
+                  standardizedMapped[uniqueKey][key] = row[key]
                 })
               }
 
-              standardizedMapped[uniqueKey][row[description.seriesKey]] = row[valueKey];
-            });
+              standardizedMapped[uniqueKey][row[description.seriesKey]] = row[valueKey]
+            })
           })
 
           Object.keys(standardizedMapped).forEach(key => {
-            if(!description.ignoredKeys || description.ignoredKeys.indexOf(standardizedMapped[key]['**Numeric Value Property**']) === -1){
-              standardized.push(standardizedMapped[key]);
+            if (!description.ignoredKeys || description.ignoredKeys.indexOf(standardizedMapped[key]['**Numeric Value Property**']) === -1) {
+              standardized.push(standardizedMapped[key])
             }
           })
 
-          return standardized;
+          return standardized
         } else {
           let standardizedMapped = {}
           let standardized = []
@@ -190,14 +190,14 @@ export class DataTransform {
           return standardized
         }
       } else {
-        return undefined;
+        return undefined
       }
     }
 
-    return data;
+    return data
   }
 
-    /**
+  /**
      * cleanData
      *
     // This cleans a data set by:
@@ -207,21 +207,21 @@ export class DataTransform {
     *
     * Inputs: data as array, excludeKey indicates which key to use to NOT clean
     *                        Example: "Date" should not be cleaned if part of the data
-    * 
+    *
     * Output: returns the cleanedData
-    * 
+    *
     * Set testing = true if you need to see before and after data
-    * 
+    *
     */
-  cleanData (data, excludeKey, testing = false) {
+  cleanData(data, excludeKey, testing = false) {
     let cleanedupData = []
     if (testing) console.log('## Data to clean=', data)
     if (excludeKey === undefined) {
       console.log('COVE: cleanData excludeKey undefined')
-      return data // because no excludeKey 
+      return data // because no excludeKey
     }
     data.forEach(function (d, i) {
-      if (testing) console.log("clean", i, " d", d);
+      if (testing) console.log('clean', i, ' d', d)
       let cleaned = {}
       Object.keys(d).forEach(function (key) {
         if (key === excludeKey) {
@@ -229,27 +229,27 @@ export class DataTransform {
           cleaned[key] = d[key]
         } else {
           // remove comma and dollar signs
-          if (testing) console.log("typeof d[key] is ", typeof d[key]);
-          let tmp = "";
+          if (testing) console.log('typeof d[key] is ', typeof d[key])
+          let tmp = ''
           if (typeof d[key] === 'string') {
             tmp = d[key] !== null && d[key] !== '' ? d[key].replace(/[,\$]/g, '') : ''
           } else {
-            tmp =  d[key] !== null && d[key] !== '' ? d[key] : ''
+            tmp = d[key] !== null && d[key] !== '' ? d[key] : ''
           }
           if ((tmp !== '' && tmp !== null && !isNaN(tmp)) || (tmp !== '' && tmp !== null && /\d+\.?\d*/.test(tmp))) {
             cleaned[key] = tmp
-          } else { cleaned[key] = '' }
+          } else {
+            cleaned[key] = ''
+          }
           // if you get here, then return nothing to skip bad data point
         }
       })
-      if (testing) console.log("cleaned=", cleaned)
+      if (testing) console.log('cleaned=', cleaned)
       cleanedupData.push(cleaned)
     })
     if (testing) console.log('## cleanedData =', cleanedupData)
     return cleanedupData
   }
-
-
 }
 
 export default DataTransform

package/helpers/cove/date.js

@@ -0,0 +1,9 @@
+import { timeFormat, timeParse } from 'd3-time-format'
+
+export function formatDate(format = undefined, date) {
+  return timeFormat(format)(date)
+}
+
+export function parseDate(format = undefined, dateString) {
+  return timeParse(format)(dateString) || new Date()
+}

package/helpers/cove/number.js

@@ -0,0 +1,166 @@
+import numberFromString from '@cdc/core/helpers/numberFromString'
+
+const abbreviateNumber = num => {
+  let unit = ''
+  let absNum = Math.abs(num)
+
+  if (absNum >= 1e9) {
+    unit = 'B'
+    num = num / 1e9
+  } else if (absNum >= 1e6) {
+    unit = 'M'
+    num = num / 1e6
+  } else if (absNum >= 1e3) {
+    unit = 'K'
+    num = num / 1e3
+  }
+
+  return num + unit
+}
+
+// Format numeric data based on settings in config
+const formatNumber = (num, axis, shouldAbbreviate = false, config = null, addColParams = null) => {
+  if (!config) console.error('no config found in formatNumber')
+  // if num is NaN return num
+  if (isNaN(num) || !num) return num
+  // Check if the input number is negative
+  const isNegative = num < 0
+
+  // If the input number is negative, take the absolute value
+  if (isNegative) {
+    num = Math.abs(num)
+  }
+
+  // destructure dataFormat values
+  let {
+    dataFormat: { commas, abbreviated, roundTo, prefix, suffix, rightRoundTo, bottomRoundTo, rightPrefix, rightSuffix, bottomPrefix, bottomSuffix, bottomAbbreviated }
+  } = config
+
+  // destructure Additional Col dataformat values
+  const { addColCommas, addColRoundTo, addColPrefix, addColSuffix } = addColParams
+
+  // check if value contains comma and remove it. later will add comma below.
+  if (String(num).indexOf(',') !== -1) num = num.replaceAll(',', '')
+
+  let original = num
+  let stringFormattingOptions
+  if (axis === 'left') {
+      let roundToPlace
+      if (addColRoundTo !== undefined) {
+        // if its an Additional Column
+        roundToPlace = addColRoundTo ? Number(addColRoundTo) : 0
+      } else {
+        roundToPlace = roundTo ? Number(roundTo) : 0
+      }
+      // Need to prevent negative values in rounding
+      if (roundToPlace < 0) roundToPlace = 0
+      let useCommas
+      if (addColCommas !== undefined) {
+        // if its an Additional Column
+        useCommas = addColCommas ? true : false
+      } else {
+        useCommas = config.dataFormat.commas ? true : false
+      }
+      stringFormattingOptions = {
+        useGrouping: useCommas,
+        minimumFractionDigits: roundToPlace,
+        maximumFractionDigits: roundToPlace
+      }
+  }
+
+  if (axis === 'right') {
+    stringFormattingOptions = {
+      useGrouping: config.dataFormat.rightCommas ? true : false,
+      minimumFractionDigits: rightRoundTo ? Number(rightRoundTo) : 0,
+      maximumFractionDigits: rightRoundTo ? Number(rightRoundTo) : 0
+    }
+  }
+
+  if (axis === 'bottom') {
+    stringFormattingOptions = {
+      useGrouping: config.dataFormat.bottomCommas ? true : false,
+      minimumFractionDigits: bottomRoundTo ? Number(bottomRoundTo) : 0,
+      maximumFractionDigits: bottomRoundTo ? Number(bottomRoundTo) : 0
+    }
+  }
+
+  num = numberFromString(num)
+
+  if (isNaN(num)) {
+    config.runtime.editorErrorMessage = `Unable to parse number from data ${original}. Try reviewing your data and selections in the Data Series section.`
+    return original
+  }
+
+  if (!config.dataFormat) return num
+  if (config.dataCutoff) {
+    let cutoff = numberFromString(config.dataCutoff)
+
+    if (num < cutoff) {
+      num = cutoff
+    }
+  }
+
+  // When we're formatting the left axis
+  // Use commas also updates bars and the data table
+  // We can't use commas when we're formatting the dataFormatted number
+  // Example: commas -> 12,000; abbreviated -> 12k (correct); abbreviated & commas -> 12 (incorrect)
+  //
+  // Edge case for small numbers with decimals
+  // - if roundTo undefined which means it is blank, then do not round
+
+  if ((axis === 'left' && commas && abbreviated && shouldAbbreviate) || (axis === 'bottom' && commas && abbreviated && shouldAbbreviate)) {
+    num = num // eslint-disable-line
+  } else {
+    num = num.toLocaleString('en-US', stringFormattingOptions)
+  }
+  let result = ''
+
+  if (abbreviated && axis === 'left' && shouldAbbreviate) {
+    num = abbreviateNumber(parseFloat(num))
+  }
+
+  if (bottomAbbreviated && axis === 'bottom' && shouldAbbreviate) {
+    num = abbreviateNumber(parseFloat(num))
+  }
+
+  if (addColPrefix !== undefined && axis === 'left') {
+      result = addColPrefix + result
+  } else {
+    if (prefix && axis === 'left') {
+      result = prefix + result
+    }
+  }
+
+  if (rightPrefix && axis === 'right') {
+    result += rightPrefix
+  }
+
+  if (bottomPrefix && axis === 'bottom') {
+    result += bottomPrefix
+  }
+
+  result += num
+
+  if (addColSuffix !== undefined && axis === 'left') {
+    result += addColSuffix
+  } else {
+    if (suffix && axis === 'left') {
+      result += suffix
+    }
+  }
+
+  if (rightSuffix && axis === 'right') {
+    result += rightSuffix
+  }
+
+  if (bottomSuffix && axis === 'bottom') {
+    result += bottomSuffix
+  }
+  if (isNegative) {
+    result = '-' + result
+  }
+
+  return String(result)
+}
+
+export { formatNumber }

package/helpers/coveUpdateWorker.js

@@ -0,0 +1,15 @@
+// If config key names or position in the config have been changed with a version change,
+// process those config entries and format old values into new
+import update_4_23 from './ver/4.23'
+
+// 4.23.6 ------------------------------------------------------
+const coveUpdateWorker = async config => {
+  let genConfig = config
+
+  // v4.23
+  genConfig = await update_4_23(genConfig)
+
+  return genConfig
+}
+
+export default coveUpdateWorker

package/helpers/fetchRemoteData.js

@@ -14,10 +14,20 @@ export default async function (url, visualizationType = '') {
       data = await fetch(url.href)
         .then(response => response.text())
         .then(responseText => {
+          // for every comma NOT inside quotes, replace with a pipe delimiter
+          // - this will let commas inside the quotes not be parsed as a new column
+          // - Limitation: if a delimiter other than comma is used in the csv this will break
+          // Examples of other delimiters that would break: tab
+          responseText = responseText.replace(/(".*?")|,/g, (...m) => m[1] || '|')
+          // now strip the double quotes
+          responseText = responseText.replace(/["]+/g, '')
           const parsedCsv = Papa.parse(responseText, {
+            //quotes: "true",  // dont need these
+            //quoteChar: "'",  // has no effect that I can tell
             header: true,
-            dynamicTyping: true,
-            skipEmptyLines: true
+            skipEmptyLines: true,
+            delimiter: '|', // we are using pipe symbol as delimiter so setting this explicitly for Papa.parse
+            dynamicTyping: false
           })
           return parsedCsv.data
         })

package/helpers/ver/4.23.js

@@ -0,0 +1,10 @@
+const update_4_23 = async config => {
+  const ver = 4.23
+
+  let newConfig = { ...config }
+
+  newConfig.validated = ver
+  return newConfig
+}
+
+export default update_4_23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cdc/core",
-  "version": "4.23.5",
+  "version": "4.23.7",
   "description": "Core components, styles, hooks, and helpers, for the CDC Open Visualization project",
   "moduleName": "CdcCore",
   "main": "dist/cdccore",
@@ -30,5 +30,5 @@
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
   },
-  "gitHead": "34add3436994ca3cf13e51f313add4d70377f53e"
+  "gitHead": "6c7ac5215dcf3bc1cc7d199089c8c2e75f53a93e"
 }

package/styles/v2/components/input/_input.scss

@@ -2,9 +2,9 @@
   display: block;
   position: relative;
   padding: 0.5em 0.5em;
-  border-width: 1px;
-  border-style: solid;
-  border-color: #cbcbcb;
+  border-width: 1px !important; // intentional use of !important for CDC
+  border-style: solid !important; // intentional use of !important for CDC
+  border-color: #cbcbcb !important; // intentional use of !important for CDC
   border-radius: 0.1875rem;
   transition: border-color 200ms $transition-expo-out;
   font-family: sans-serif;