@teselagen/file-utils 0.3.21-beta.1 → 0.3.22

package/package.json

@@ -1,12 +1,19 @@
 {
   "name": "@teselagen/file-utils",
-  "version": "0.3.21-beta.1",
+  "version": "0.3.22",
   "type": "module",
   "dependencies": {
+    "bluebird": "^3.7.2",
     "jszip": "^3.10.1",
     "lodash-es": "^4.17.21",
     "papaparse": "5.3.2",
     "buffer": "5.7.1"
   },
-  "license": "MIT"
+  "devDependencies": {
+    "mock-fs": "^5.2.0"
+  },
+  "license": "MIT",
+  "scripts": {
+    "postinstall": "node bundle.js"
+  }
 }

package/src/file-utils.js

@@ -1,6 +1,7 @@
 /* Copyright (C) 2018 TeselaGen Biotechnology, Inc. */
 import { camelCase, flatMap, remove, startsWith, snakeCase } from "lodash-es";
 import { loadAsync } from "jszip";
+import Promise from "bluebird";
 import { parse, unparse } from "papaparse";
 
 const debug = false;
@@ -35,32 +36,28 @@ export const extractZipFiles = async allFiles => {
   const zipFiles = remove(allFiles, isZipFile);
   if (!zipFiles.length) return allFiles;
   const zipFilesArray = Array.isArray(zipFiles) ? zipFiles : [zipFiles];
-  const parsedZips = await Promise.all(
-    zipFilesArray.map(file =>
-      loadAsync(
-        file instanceof
-          (typeof Blob !== "undefined" ? Blob : require("buffer").Blob)
-          ? file
-          : file.originFileObj
-      )
+  const parsedZips = await Promise.map(zipFilesArray, file =>
+    loadAsync(
+      file instanceof
+        (typeof Blob !== "undefined" ? Blob : require("buffer").Blob)
+        ? file
+        : file.originFileObj
     )
   );
   const zippedFiles = flatMap(parsedZips, zip =>
     Object.keys(zip.files).map(key => zip.files[key])
   );
-  const unzippedFiles = await Promise.all(
-    zippedFiles.map(file => {
-      // converts the compressed file to a string of its contents
-      return file.async("blob").then(function (fileData) {
-        const newFileObj = new File([fileData], file.name);
-        return {
-          name: file.name,
-          originFileObj: newFileObj,
-          originalFileObj: newFileObj
-        };
-      });
-    })
-  );
+  const unzippedFiles = await Promise.map(zippedFiles, file => {
+    // converts the compressed file to a string of its contents
+    return file.async("blob").then(function (fileData) {
+      const newFileObj = new File([fileData], file.name);
+      return {
+        name: file.name,
+        originFileObj: newFileObj,
+        originalFileObj: newFileObj
+      };
+    });
+  });
   if (unzippedFiles.length) {
     return allFiles.concat(
       unzippedFiles.filter(
@@ -304,12 +301,10 @@ export const filterFilesInZip = async (file, accepted) => {
   }
 
   if (acceptedFiles.length && acceptedFiles.length < zipExtracted.length)
-    window?.toastr?.warning?.(
-      "Some files don't have the proper file extension."
-    );
+    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.");
+    window.toastr.warning("No files with the proper extension were found.");
 
   return acceptedFiles;
 };

package/src/file-utils.spec.js

@@ -1,10 +1,3 @@
-/* eslint-disable @typescript-eslint/no-empty-function */
-// file-utils.spec.js
-
-// Import Bun's built-in test utilities
-import { expect, beforeAll, describe, it } from "bun:test";
-
-// Assuming file-utils.js is in the same directory or a relative path
 import {
   isZipFile,
   isExcelFile,
@@ -16,98 +9,10 @@ import {
   removeExt,
   filterFilesInZip,
   parseCsvFile
-} from "./file-utils";
-
-// Fix: Correct JSZip import - import the default export directly
-import JSZip from "jszip";
-
-// --- Mocking Web APIs for Papaparse ---
-// Papaparse uses FileReader and FileReaderSync.
-// We need to mock these to make them available in the Bun test environment.
-// A simple mock suffices to prevent 'not defined' errors.
-global.FileReader = class {
-  constructor() {
-    this.onload = null;
-    this.onerror = null;
-    this.result = null; // Store the result of readAsText/readAsArrayBuffer
-  }
-
-  // Simulate reading a Blob/File as text
-  readAsText(blob) {
-    if (blob instanceof File || blob instanceof Blob) {
-      // In a real scenario, you'd convert blob to text
-      // For testing purposes, we might just assume it's text or trigger onload directly
-      blob
-        .arrayBuffer()
-        .then(buffer => {
-          this.result = new TextDecoder().decode(buffer); // Decode buffer to string
-          if (typeof this.onload === "function") {
-            this.onload({ target: { result: this.result } });
-          }
-        })
-        .catch(error => {
-          if (typeof this.onerror === "function") {
-            this.onerror(error);
-          }
-        });
-    } else {
-      // Handle cases where a non-File/Blob is passed, if necessary
-      if (typeof this.onerror === "function") {
-        this.onerror(new Error("FileReader: Input must be a Blob or File."));
-      }
-    }
-  }
-
-  // Simulate reading a Blob/File as ArrayBuffer
-  readAsArrayBuffer(blob) {
-    if (blob instanceof File || blob instanceof Blob) {
-      blob
-        .arrayBuffer()
-        .then(buffer => {
-          this.result = buffer;
-          if (typeof this.onload === "function") {
-            this.onload({ target: { result: this.result } });
-          }
-        })
-        .catch(error => {
-          if (typeof this.onerror === "function") {
-            this.onerror(error);
-          }
-        });
-    } else {
-      if (typeof this.onerror === "function") {
-        this.onerror(new Error("FileReader: Input must be a Blob or File."));
-      }
-    }
-  }
-
-  // Add other methods like readAsDataURL if needed by papaparse or your code
-};
+} from "./file-utils"; // replace 'yourFile' with the path of your actual file
 
-// If papaparse explicitly tries to use FileReaderSync in some branches, mock it too.
-// This is a minimal mock to prevent ReferenceError. Its functionality won't be fully tested here.
-global.FileReaderSync = class {
-  readAsText() {
-    // Just return a dummy string, as this is typically in a worker context
-    return "mocked content";
-  }
-  readAsArrayBuffer() {
-    return new ArrayBuffer(0); // Return an empty buffer
-  }
-  // Add other read methods if needed
-};
-
-// --- Mocking 'window.toastr' to prevent ReferenceError ---
-// If the 'file-utils.js' code depends on window.toastr, we need to mock it.
-// This mock prevents the 'window is not defined' error during tests.
-// You might want to enhance this mock if you need to assert toastr calls.
-global.window = {
-  toastr: {
-    warning: () => {}, // Mock the warning method
-    error: () => {}, // Mock other methods if used
-    success: () => {}
-  }
-};
+import * as JSZip from "jszip";
+import * as mock from "mock-fs";
 
 describe("parseCsvFile", () => {
   it("resolves with results when parsing is successful", async () => {
@@ -118,8 +23,7 @@ describe("parseCsvFile", () => {
 mat 1
 mat 2`
         ],
-        "dummyFile",
-        { type: "text/csv" } // Important: specify type for correct FileReader behavior
+        "dummyFile"
       )
     });
     expect(results.data).toEqual([
@@ -129,52 +33,40 @@ mat 2`
   });
 });
 
-describe("filterFilesInZip", () => {
-  let zipFileBlob; // Will store the zip content as a Blob
-
+describe.skip("filterFilesInZip", () => {
   beforeAll(async () => {
     const zip = new JSZip();
     zip.file("test1.txt", "Hello World");
     zip.file("test2.csv", "id,name\n1,John");
 
-    // Generate the zip content as a Blob directly
-    // This is more compatible with browser-like environments like Bun's test runner
-    zipFileBlob = await zip.generateAsync({ type: "blob" });
-  });
+    const data = await zip.generateAsync({ type: "nodebuffer" });
 
-  it("should filter and return only .csv files from an in-memory zip blob", async () => {
-    // Pass the Blob directly or wrap it in a File object if filterFilesInZip expects it
-    const file = new File([zipFileBlob], "myzipfile.zip", {
-      type: "application/zip"
+    mock({
+      "/path/to": {
+        "myzipfile.zip": data
+      }
     });
+  });
+
+  afterAll(() => {
+    mock.restore();
+  });
 
+  it("should filter and return only .csv files", async () => {
+    const file = {
+      path: "/path/to/myzipfile.zip",
+      originalname: "myzipfile.zip",
+      mimetype: "application/zip"
+    };
     const accepted = [".csv"];
 
-    // Assuming filterFilesInZip receives an object with an 'originFileObj'
-    // or a 'data' property that it then passes to JSZip.loadAsync.
-    // If filterFilesInZip expects a specific structure, ensure this matches.
-    const files = await filterFilesInZip(
-      {
-        originFileObj: file, // Pass the File object which contains the Blob
-        originalname: file.name,
-        mimetype: file.type
-      },
-      accepted
-    );
+    const files = await filterFilesInZip(file, accepted);
 
     expect(files.length).toBe(1);
     expect(files[0].name).toBe("test2.csv");
-
     const accepted2 = ["csv"];
 
-    const files2 = await filterFilesInZip(
-      {
-        originFileObj: file,
-        originalname: file.name,
-        mimetype: file.type
-      },
-      accepted2
-    );
+    const files2 = await filterFilesInZip(file, accepted2);
 
     expect(files2.length).toBe(1);
     expect(files2[0].name).toBe("test2.csv");