@teselagen/file-utils 0.2.1 → 0.2.2

package/{src/file-utils.js → index.js}

@@ -1,45 +1,40 @@
-/* Copyright (C) 2018 TeselaGen Biotechnology, Inc. */
+// packages/file-utils/src/file-utils.js
 import { camelCase, flatMap, remove, startsWith, snakeCase } from "lodash";
 import { loadAsync } from "jszip";
-import Promise from "bluebird";
+import Promise2 from "bluebird";
 import { parse, unparse } from "papaparse";
-
-const logDebug = (...args) => {
+var logDebug = (...args) => {
   if (process.env.DEBUG_CSV_PARSING) {
-    // eslint-disable-next-line no-console
     console.log(...args);
   }
 };
-
-export const allowedCsvFileTypes = [".csv", ".txt", ".xlsx"];
-
-export const isZipFile = file => {
+var allowedCsvFileTypes = [".csv", ".txt", ".xlsx"];
+var isZipFile = (file) => {
   const type = file.mimetype || file.type;
   return type === "application/zip" || type === "application/x-zip-compressed";
 };
-
-export const getExt = file => file.name.split(".").pop();
-export const isExcelFile = file => getExt(file) === "xlsx";
-export const isCsvFile = file => getExt(file) === "csv";
-export const isTextFile = file => ["text", "txt"].includes(getExt(file));
-
-export const isCsvOrExcelFile = file => isCsvFile(file) || isExcelFile(file);
-
-export const extractZipFiles = async allFiles => {
-  if (!Array.isArray(allFiles)) allFiles = [allFiles];
-  // make a copy so we don't mutate the form value
+var getExt = (file) => file.name.split(".").pop();
+var isExcelFile = (file) => getExt(file) === "xlsx";
+var isCsvFile = (file) => getExt(file) === "csv";
+var isTextFile = (file) => ["text", "txt"].includes(getExt(file));
+var isCsvOrExcelFile = (file) => isCsvFile(file) || isExcelFile(file);
+var extractZipFiles = async (allFiles) => {
+  if (!Array.isArray(allFiles))
+    allFiles = [allFiles];
   allFiles = [...allFiles];
   const zipFiles = remove(allFiles, isZipFile);
-  if (!zipFiles.length) return allFiles;
+  if (!zipFiles.length)
+    return allFiles;
   const zipFilesArray = Array.isArray(zipFiles) ? zipFiles : [zipFiles];
-  const parsedZips = await Promise.map(zipFilesArray, file =>
-    loadAsync(file instanceof Blob ? file : file.originFileObj)
+  const parsedZips = await Promise2.map(
+    zipFilesArray,
+    (file) => loadAsync(file instanceof Blob ? file : file.originFileObj)
   );
-  const zippedFiles = flatMap(parsedZips, zip =>
-    Object.keys(zip.files).map(key => zip.files[key])
+  const zippedFiles = flatMap(
+    parsedZips,
+    (zip) => Object.keys(zip.files).map((key) => zip.files[key])
   );
-  const unzippedFiles = await Promise.map(zippedFiles, file => {
-    // converts the compressed file to a string of its contents
+  const unzippedFiles = await Promise2.map(zippedFiles, (file) => {
     return file.async("blob").then(function(fileData) {
       const newFileObj = new File([fileData], file.name);
       return {
@@ -52,38 +47,32 @@ export const extractZipFiles = async allFiles => {
   if (unzippedFiles.length) {
     return allFiles.concat(
       unzippedFiles.filter(
-        ({ name, originFileObj }) =>
-          !name.includes("__MACOSX") &&
-          !name.includes(".DS_Store") &&
-          originFileObj.size !== 0
+        ({ name, originFileObj }) => !name.includes("__MACOSX") && !name.includes(".DS_Store") && originFileObj.size !== 0
       )
     );
   } else {
     return allFiles;
   }
 };
-
-const defaultCsvParserOptions = {
+var defaultCsvParserOptions = {
   header: true,
   skipEmptyLines: "greedy",
   trimHeaders: true
 };
-export const setupCsvParserOptions = (parserOptions = {}) => {
+var setupCsvParserOptions = (parserOptions = {}) => {
   const {
     camelCaseHeaders = false,
     lowerCaseHeaders = false,
     ...rest
   } = parserOptions;
-
   const papaParseOpts = { ...rest };
   if (camelCaseHeaders) {
     logDebug("[CSV-PARSER] camelCasing headers");
-    papaParseOpts.transformHeader = header => {
+    papaParseOpts.transformHeader = (header) => {
       let transHeader = header;
       if (!startsWith(header.trim(), "ext-")) {
         transHeader = camelCase(header);
       }
-
       if (transHeader) {
         logDebug(
           `[CSV-PARSER] Transformed header from: ${header} to: ${transHeader}`
@@ -92,16 +81,14 @@ export const setupCsvParserOptions = (parserOptions = {}) => {
       } else {
         logDebug(`[CSV-PARSER] Not transforming header: ${header}`);
       }
-
       return transHeader;
     };
   } else if (lowerCaseHeaders) {
-    papaParseOpts.transformHeader = header => {
+    papaParseOpts.transformHeader = (header) => {
       let transHeader = header;
       if (!startsWith(header, "ext-")) {
         transHeader = header.toLowerCase();
       }
-
       if (transHeader) {
         logDebug(
           `[CSV-PARSER] Transformed header from: ${header} to: ${transHeader}`
@@ -110,35 +97,30 @@ export const setupCsvParserOptions = (parserOptions = {}) => {
       } else {
         logDebug(`[CSV-PARSER] Not transforming header: ${header}`);
       }
-
       return transHeader;
     };
   }
-
   return papaParseOpts;
 };
-
-const normalizeCsvHeaderHelper = h => snakeCase(h.toUpperCase()).toUpperCase();
-
-export function normalizeCsvHeader(header) {
+var normalizeCsvHeaderHelper = (h) => snakeCase(h.toUpperCase()).toUpperCase();
+function normalizeCsvHeader(header) {
   if (header.startsWith("ext-") || header.startsWith("EXT-")) {
     return header;
   }
   return normalizeCsvHeaderHelper(header);
 }
-
-export const parseCsvFile = (csvFile, parserOptions = {}) => {
-  return new Promise((resolve, reject) => {
+var parseCsvFile = (csvFile, parserOptions = {}) => {
+  return new Promise2((resolve, reject) => {
     const opts = {
       ...defaultCsvParserOptions,
       ...setupCsvParserOptions(parserOptions),
-      complete: results => {
+      complete: (results) => {
         if (results && results.errors && results.errors.length) {
           return reject("Error in csv: " + JSON.stringify(results.errors));
         }
         resolve(results);
       },
-      error: error => {
+      error: (error) => {
         reject(error);
       }
     };
@@ -146,28 +128,11 @@ export const parseCsvFile = (csvFile, parserOptions = {}) => {
     parse(csvFile.originFileObj, opts);
   });
 };
-
-/**
- * Gets a properly formatted json object into s csv string
- * https://www.papaparse.com/docs#json-to-csv
- * const options = {
-      quotes: false, //or array of booleans
-      quoteChar: '"',
-      escapeChar: '"',
-      delimiter: ",",
-      header: true,
-      newline: "\r\n",
-      skipEmptyLines: false, //other option is 'greedy', meaning skip delimiters, quotes, and whitespace.
-      columns: null //or array of strings
-    }
- * @returns csv as string
- */
-export const jsonToCsv = (jsonData, options = {}) => {
+var jsonToCsv = (jsonData, options = {}) => {
   const csv = unparse(jsonData, options);
   return csv;
 };
-
-export const parseCsvString = (csvString, parserOptions = {}) => {
+var parseCsvString = (csvString, parserOptions = {}) => {
   const opts = {
     ...defaultCsvParserOptions,
     ...setupCsvParserOptions(parserOptions)
@@ -175,27 +140,25 @@ export const parseCsvString = (csvString, parserOptions = {}) => {
   logDebug(`[CSV-PARSER] parseCsvString opts:`, opts);
   return parse(csvString, opts);
 };
-
-export async function parseCsvOrExcelFile(
-  fileOrFiles,
-  { csvParserOptions } = {}
-) {
+async function parseCsvOrExcelFile(fileOrFiles, { csvParserOptions } = {}) {
   let csvFile, excelFile, txtFile;
   if (Array.isArray(fileOrFiles)) {
     csvFile = fileOrFiles.find(isCsvFile);
     excelFile = fileOrFiles.find(isExcelFile);
     txtFile = fileOrFiles.find(isTextFile);
   } else {
-    if (isExcelFile(fileOrFiles)) excelFile = fileOrFiles;
-    else if (isCsvFile(fileOrFiles)) csvFile = fileOrFiles;
-    else if (isTextFile(fileOrFiles)) txtFile = fileOrFiles;
+    if (isExcelFile(fileOrFiles))
+      excelFile = fileOrFiles;
+    else if (isCsvFile(fileOrFiles))
+      csvFile = fileOrFiles;
+    else if (isTextFile(fileOrFiles))
+      txtFile = fileOrFiles;
   }
   if (!csvFile && !excelFile && !txtFile) {
     throw new Error("No csv or excel files found");
   }
-
-  if (!csvFile && !excelFile) csvFile = txtFile;
-
+  if (!csvFile && !excelFile)
+    csvFile = txtFile;
   if (!csvFile && excelFile && window.parseExcelToCsv) {
     csvFile = await window.parseExcelToCsv(
       excelFile.originFileObj || excelFile
@@ -210,13 +173,8 @@ export async function parseCsvOrExcelFile(
   parsedCsv.originalFile = csvFile;
   return parsedCsv;
 }
-
-export const validateCSVRequiredHeaders = (
-  fields,
-  requiredHeaders,
-  filename
-) => {
-  const missingRequiredHeaders = requiredHeaders.filter(field => {
+var validateCSVRequiredHeaders = (fields, requiredHeaders, filename) => {
+  const missingRequiredHeaders = requiredHeaders.filter((field) => {
     return !fields.includes(field);
   });
   if (missingRequiredHeaders.length) {
@@ -226,91 +184,64 @@ export const validateCSVRequiredHeaders = (
     )})`;
   }
 };
-
-export const validateCSVRow = (row, requiredHeaders, index) => {
-  const missingRequiredFields = requiredHeaders.filter(field => !row[field]);
+var validateCSVRow = (row, requiredHeaders, index) => {
+  const missingRequiredFields = requiredHeaders.filter((field) => !row[field]);
   if (missingRequiredFields.length) {
     if (missingRequiredFields.length === 1) {
-      return `Row ${index + 1} is missing the required field "${
-        missingRequiredFields[0]
-      }"`;
+      return `Row ${index + 1} is missing the required field "${missingRequiredFields[0]}"`;
     } else {
-      return `Row ${index +
-        1} is missing these required fields: ${missingRequiredFields.join(
+      return `Row ${index + 1} is missing these required fields: ${missingRequiredFields.join(
         ", "
       )}`;
     }
   }
 };
-
-export const cleanCommaSeparatedCell = cellData =>
-  (cellData || "")
-    .split(",")
-    .map(n => n.trim())
-    .filter(n => n);
-
-/**
- * Because the csv rows might not have the same header keys in some cases (extended properties)
- * this function will make sure that each row will have all headers so that the export
- * does not drop fields
- * @param {*} rows
- */
-export const cleanCsvExport = rows => {
+var cleanCommaSeparatedCell = (cellData) => (cellData || "").split(",").map((n) => n.trim()).filter((n) => n);
+var cleanCsvExport = (rows) => {
   const allHeaders = [];
-  rows.forEach(row => {
-    Object.keys(row).forEach(header => {
+  rows.forEach((row) => {
+    Object.keys(row).forEach((header) => {
       if (!allHeaders.includes(header)) {
         allHeaders.push(header);
       }
     });
   });
-  rows.forEach(row => {
-    allHeaders.forEach(header => {
+  rows.forEach((row) => {
+    allHeaders.forEach((header) => {
       row[header] = row[header] || "";
     });
   });
   return rows;
 };
-
-export const filterFilesInZip = async (file, accepted) => {
+var filterFilesInZip = async (file, accepted) => {
   const zipExtracted = await extractZipFiles(file);
   const acceptedFiles = [];
   for (const extFile of zipExtracted) {
     const extension = "." + getExt(extFile);
-    if (accepted.some(ext => ext === extension)) {
+    if (accepted.some((ext) => ext === extension)) {
       acceptedFiles.push(extFile);
     }
   }
-
   if (acceptedFiles.length && acceptedFiles.length < zipExtracted.length)
     window.toastr.warning("Some files don't have the proper file extension.");
-
   if (!acceptedFiles.length)
     window.toastr.warning("No files with the proper extension were found.");
-
   return acceptedFiles;
 };
-
-export function removeExt(filename) {
+function removeExt(filename) {
   if (filename && filename.includes(".")) {
-    return filename
-      .split(".")
-      .slice(0, -1)
-      .join(".");
+    return filename.split(".").slice(0, -1).join(".");
   } else {
     return filename;
   }
 }
-
-export async function uploadAndProcessFiles(files = []) {
-  if (!files.length) return null;
-
+async function uploadAndProcessFiles(files = []) {
+  if (!files.length)
+    return null;
   const formData = new FormData();
   files.forEach(({ originFileObj }) => formData.append("file", originFileObj));
-
   const response = await window.api.post("/user_uploads/", formData);
-
-  return response.data.map(d => ({
+  return response.data.map((d) => ({
     encoding: d.encoding,
     mimetype: d.mimetype,
     originalname: d.originalname,
@@ -318,8 +249,7 @@ export async function uploadAndProcessFiles(files = []) {
     size: d.size
   }));
 }
-
-export async function encodeFilesForRequest(files) {
+async function encodeFilesForRequest(files) {
   const encodedFiles = [];
   for (const file of files) {
     const encoded = await fileToBase64(file.originalFileObj);
@@ -332,16 +262,36 @@ export async function encodeFilesForRequest(files) {
   }
   return encodedFiles;
 }
-
-const fileToBase64 = file => {
-  return new Promise(resolve => {
+var fileToBase64 = (file) => {
+  return new Promise2((resolve) => {
     const reader = new FileReader();
-    // Read file content on file loaded event
     reader.onload = function(event) {
       resolve(event.target.result);
     };
-
-    // Convert data to base64
     reader.readAsDataURL(file);
   });
 };
+export {
+  allowedCsvFileTypes,
+  cleanCommaSeparatedCell,
+  cleanCsvExport,
+  encodeFilesForRequest,
+  extractZipFiles,
+  filterFilesInZip,
+  getExt,
+  isCsvFile,
+  isCsvOrExcelFile,
+  isExcelFile,
+  isTextFile,
+  isZipFile,
+  jsonToCsv,
+  normalizeCsvHeader,
+  parseCsvFile,
+  parseCsvOrExcelFile,
+  parseCsvString,
+  removeExt,
+  setupCsvParserOptions,
+  uploadAndProcessFiles,
+  validateCSVRequiredHeaders,
+  validateCSVRow
+};

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@teselagen/file-utils",
-  "version": "0.2.1",
-  "type": "commonjs",
+  "version": "0.2.2",
+  "type": "module",
   "dependencies": {
     "bluebird": "^3.7.2",
     "jszip": "^3.10.1",
     "lodash": "^4.17.21",
     "papaparse": "^5.4.1"
-  }
+  },
+  "module": "index.js",
+  "main": "index.js"
 }

package/.eslintrc.json

@@ -1,18 +0,0 @@
-{
-  "extends": ["../../.eslintrc.json"],
-  "ignorePatterns": ["!**/*"],
-  "overrides": [
-    {
-      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
-      "rules": {}
-    },
-    {
-      "files": ["*.ts", "*.tsx"],
-      "rules": {}
-    },
-    {
-      "files": ["*.js", "*.jsx"],
-      "rules": {}
-    }
-  ]
-}

package/jest.config.js

@@ -1,10 +0,0 @@
-/* eslint-disable */
-module.exports = {
-  displayName: 'file-utils',
-  preset: '../../jest.preset.js',
-  transform: {
-    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
-  },
-  moduleFileExtensions: ['ts', 'js', 'html'],
-  coverageDirectory: '../../coverage/packages/file-utils',
-};

package/project.json

@@ -1,51 +0,0 @@
-{
-  "name": "file-utils",
-  "$schema": "../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "packages/file-utils/src",
-  "projectType": "library",
-  "targets": {
- "version": {
-      "executor": "@jscutlery/semver:version",
-      "options": {
-        "preset": "conventional"
-      }
-    },
-    "build": {
-      "executor": "@nx/esbuild:esbuild",
-      "outputs": ["{options.outputPath}"],
-      "options": {
-        "outputPath": "dist/packages/file-utils",
-        "main": "packages/file-utils/src/index.js",
-        "tsConfig": "packages/file-utils/tsconfig.lib.json",
-        "assets": ["packages/file-utils/*.md"],
-        "generatePackageJson": true
-      }
-    },
-    "publish": {
-      "command": "node tools/scripts/publish.mjs file-utils {args.ver} {args.tag}",
-      "dependsOn": ["build"]
-    },
-    "lint": {
-      "executor": "@nx/linter:eslint",
-      "outputs": ["{options.outputFile}"],
-      "options": {
-        "lintFilePatterns": ["packages/file-utils/**/*.js"]
-      }
-    },
-    "test": {
-      "executor": "@nx/jest:jest",
-      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
-      "options": {
-        "jestConfig": "packages/file-utils/jest.config.js",
-        "passWithNoTests": true
-      },
-      "configurations": {
-        "ci": {
-          "ci": true,
-          "codeCoverage": true
-        }
-      }
-    }
-  },
-  "tags": []
-}

package/src/file-utils.spec.js

@@ -1,6 +0,0 @@
-import { fileUtils } from './file-utils';
-describe('fileUtils', () => {
-  it('should work', () => {
-    expect(fileUtils()).toEqual('file-utils');
-  });
-});

package/src/index.js

@@ -1 +0,0 @@
-export * from './file-utils';

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "allowJs": true,
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "noImplicitOverride": true,
-    "noPropertyAccessFromIndexSignature": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true
-  },
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}

package/tsconfig.lib.json

@@ -1,16 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "declaration": true,
-    "types": ["node"]
-  },
-  "include": ["src/**/*.ts", "src/**/*.js"],
-  "exclude": [
-    "jest.config.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.js",
-    "src/**/*.test.js"
-  ]
-}

package/tsconfig.spec.json

@@ -1,14 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "module": "commonjs",
-    "types": ["jest", "node"]
-  },
-  "include": [
-    "jest.config.ts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.d.ts"
-  ]
-}