indexeddb.js

const DB_VERSION = 1; // Use a long long for this value (don't use a float)
const DB_STORE_NAME = 'customer';
const DB_NAME = 'default';

class Database {

  constructor(name = 'default', version = 1) {
    this.name = name;
    this.version = version;
  }

  open() {
    return new Promise(function(resolve, reject) {
      let req = indexedDB.open(this.name, this.version);

      req.onsuccess = e => resolve(e.target.result);

      req.onerror = e => reject(e.target.errCode);

      req.onupgradeneeded = function (evt) {
        let store = evt.currentTarget.result.createObjectStore(
          'species', { keyPath: 'id', autoIncrement: true }
        );

        store.createIndex('name', 'name', { unique: true });
        store.createIndex('code', 'code', { unique: false });

        let db = event.target.result;

        // Create an objectStore to hold information about our customers. We're
        // going to use 'ssn' as our key path because it's guaranteed to be
        // unique - or at least that's what I was told during the kickoff meeting.
        let objectStore = db.createObjectStore('species', { keyPath: 'species', autoIncrement: true });

        // Create an index to search customers by name. We may have duplicates
        // so we can't use a unique index.
        objectStore.createIndex('name', 'name', { unique: false });

        // Create an index to search customers by email. We want to ensure that
        // no two customers have the same email, so use a unique index.
        objectStore.createIndex('email', 'email', { unique: true });

        // Use transaction oncomplete to make sure the objectStore creation is
        // finished before adding data into it.
        store.transaction.oncomplete = function(event) {
          // Store values in the newly created objectStore.
          let customerObjectStore = db.transaction('customers', 'readwrite').objectStore('customers');
          for (let i in customerData) {
            customerObjectStore.add(customerData[i]);
          }
        };
      };
    });
  }

  delete() {
    return new Promise((reject, resolve) => {
      let DBDeleteRequest = indexedDB.deleteDatabase(this.databaseName);
      DBDeleteRequest.onblocked = e => reject('Error message: Database in blocked state.');
      DBDeleteRequest.onerror = e => reject('Error deleting database.');
      // e.result should be null
      DBDeleteRequest.onsuccess = e => resolve('Database deleted successfully');
    });
  }

}

worker.js

'use strict';

// https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Functions_and_classes_available_to_workers

importScripts('xlsx.min.js');

const cdcMasterOrganismList = 'http://www.cdc.gov/nhsn/XLS/master-organism-Com-Commensals-Lists.xlsx';

const xlsxMimeTypes = [
  'application/vnd.ms-excel', /*.xls*/
  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' /*.xlsx*/
];

let reader;

function abortRead() {
  reader.abort();
}

function errorHandler(evt) {
  switch (evt.target.error.code) {
    case evt.target.error.NOT_FOUND_ERR:
      alert('File Not Found!');
      break;
    case evt.target.error.NOT_READABLE_ERR:
      alert('File is not readable');
      break;
    case evt.target.error.ABORT_ERR:
      break; // noop
    default:
      alert('An error occurred reading this file.');
  }
  ;
}

//function updateProgress(evt) {
//  // evt is an ProgressEvent.
//  if (evt.lengthComputable) {
//    let percentLoaded = Math.round((evt.loaded / evt.total) * 100);
//    // Increase the progress bar length.
//    if (percentLoaded < 100) {
//      progress.style.width = percentLoaded + '%';
//      progress.textContent = percentLoaded + '%';
//    }
//  }
//}

function parseXlsx(file) {
  'use strict';
  return new Promise(function(resolve, reject) {
    let reader         = new FileReader();
    reader.onerror     = function(e) {
      reject(e);
    };
    reader.onloadstart = function(e) {
      postMessage({
        type:             'loadstart',
        lengthComputable: e.lengthComputable,
        loaded:           e.loaded,
        timestamp:        e.timestamp,
        total:            e.total
      });
    };
    reader.onprogress  = function(e) {
      postMessage({
        type:             'progress',
        lengthComputable: e.lengthComputable,
        loaded:           e.loaded,
        timestamp:        e.timestamp,
        total:            e.total
      });
    };
    reader.onload      = function(e) {
      resolve(e.target.result);
    };
    reader.onloadend   = function(e) {
      postMessage({
        type:             'loadend',
        lengthComputable: e.lengthComputable,
        loaded:           e.loaded,
        timestamp:        e.timestamp,
        total:            e.total
      });
    };
    reader.readAsBinaryString(file);
  }).then(function(binaryString) {

    // TODO: support CSV
    let workbook = XLSX.read(binaryString, {type: 'binary'});
    return workbook.SheetNames.reduce(function(obj, sheetName) {
      obj[sheetName] = XLSX.utils.sheet_to_json(workbook.Sheets[sheetName]);
      return obj;
    }, {});
  });
}

onmessage = function(e) {
  console.log(e, e.data instanceof File);
  let data = e.data;

  if (data instanceof File) {
    parseXlsx(data)
      .then(function(data) {
        'use strict';
        postMessage({
          type: 'workbook',
          data: data
        });
      })
      .catch(function(error) {
        postMessage({
          type: 'error',
          data: error
        });
      });
  } else if (data === 'abort') {
    reader.abort();
    close();
  }

};

fetch('master-organism-Com-Commensals-Lists.xlsx')
  .then(function(result) {
    return result.blob();
  })
  .then(parseXlsx)
  .then(function(result) {
    result.map
    console.log(result);
  });