react-dropzone 11.7.0 → 12.0.2

package/src/utils/index.spec.js

@@ -1,340 +1,437 @@
 beforeEach(() => {
-  jest.resetModules()
-})
+  jest.resetModules();
+});
 
-describe('fileMatchSize()', () => {
-  let utils
+describe("fileMatchSize()", () => {
+  let utils;
   beforeEach(async () => {
-    utils = await import('./index')
-  })
-
-  it('should return true if the file object doesn\'t have a {size} property', () => {
-    expect(utils.fileMatchSize({})).toEqual([true, null])
-    expect(utils.fileMatchSize({size: null})).toEqual([true, null])
-  })
-
-  it('should return true if the minSize and maxSize were not provided', () => {
-    expect(utils.fileMatchSize({size: 100})).toEqual([true, null])
-    expect(utils.fileMatchSize({size: 100}, undefined, undefined)).toEqual([true, null])
-    expect(utils.fileMatchSize({size: 100}, null, null)).toEqual([true, null])
-  })
-
-  it('should return true if the file {size} is within the [minSize, maxSize] range', () => {
-    expect(utils.fileMatchSize({size: 100}, 10, 200)).toEqual([true, null])
-    expect(utils.fileMatchSize({size: 100}, 10, 99)).toEqual([false, { code: 'file-too-large', message: 'File is larger than 99 bytes' }])
-    expect(utils.fileMatchSize({size: 100}, 101, 200)).toEqual([false, { code: 'file-too-small', message: 'File is smaller than 101 bytes' }])
-  })
-
-  it('should return true if the file {size} is more than minSize', () => {
-    expect(utils.fileMatchSize({size: 100}, 100)).toEqual([true, null])
-    expect(utils.fileMatchSize({size: 100}, 101)).toEqual([false, { code: 'file-too-small', message: 'File is smaller than 101 bytes' }])
-  })
-
-  it('should return true if the file {size} is less than maxSize', () => {
-    expect(utils.fileMatchSize({size: 100}, undefined, 100)).toEqual([true, null])
-    expect(utils.fileMatchSize({size: 100}, null, 100)).toEqual([true, null])
-    expect(utils.fileMatchSize({size: 100}, undefined, 99)).toEqual([false, { code: 'file-too-large', message: 'File is larger than 99 bytes' }])
-    expect(utils.fileMatchSize({size: 100}, null, 99)).toEqual([false, { code: 'file-too-large', message: 'File is larger than 99 bytes' }])
-  })
-})
-
-describe('isIeOrEdge', () => {
-  let utils
+    utils = await import("./index");
+  });
+
+  it("should return true if the file object doesn't have a {size} property", () => {
+    expect(utils.fileMatchSize({})).toEqual([true, null]);
+    expect(utils.fileMatchSize({ size: null })).toEqual([true, null]);
+  });
+
+  it("should return true if the minSize and maxSize were not provided", () => {
+    expect(utils.fileMatchSize({ size: 100 })).toEqual([true, null]);
+    expect(utils.fileMatchSize({ size: 100 }, undefined, undefined)).toEqual([
+      true,
+      null,
+    ]);
+    expect(utils.fileMatchSize({ size: 100 }, null, null)).toEqual([
+      true,
+      null,
+    ]);
+  });
+
+  it("should return true if the file {size} is within the [minSize, maxSize] range", () => {
+    expect(utils.fileMatchSize({ size: 100 }, 10, 200)).toEqual([true, null]);
+    expect(utils.fileMatchSize({ size: 100 }, 10, 99)).toEqual([
+      false,
+      { code: "file-too-large", message: "File is larger than 99 bytes" },
+    ]);
+    expect(utils.fileMatchSize({ size: 100 }, 101, 200)).toEqual([
+      false,
+      { code: "file-too-small", message: "File is smaller than 101 bytes" },
+    ]);
+  });
+
+  it("should return true if the file {size} is more than minSize", () => {
+    expect(utils.fileMatchSize({ size: 100 }, 100)).toEqual([true, null]);
+    expect(utils.fileMatchSize({ size: 100 }, 101)).toEqual([
+      false,
+      { code: "file-too-small", message: "File is smaller than 101 bytes" },
+    ]);
+  });
+
+  it("should return true if the file {size} is less than maxSize", () => {
+    expect(utils.fileMatchSize({ size: 100 }, undefined, 100)).toEqual([
+      true,
+      null,
+    ]);
+    expect(utils.fileMatchSize({ size: 100 }, null, 100)).toEqual([true, null]);
+    expect(utils.fileMatchSize({ size: 100 }, undefined, 99)).toEqual([
+      false,
+      { code: "file-too-large", message: "File is larger than 99 bytes" },
+    ]);
+    expect(utils.fileMatchSize({ size: 100 }, null, 99)).toEqual([
+      false,
+      { code: "file-too-large", message: "File is larger than 99 bytes" },
+    ]);
+  });
+});
+
+describe("isIeOrEdge", () => {
+  let utils;
   beforeEach(async () => {
-    utils = await import('./index')
-  })
+    utils = await import("./index");
+  });
 
-  it('should return true for IE10', () => {
+  it("should return true for IE10", () => {
     const userAgent =
-      'Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0; .NET4.0E; .NET4.0C; .NET CLR 3.5.30729; .NET CLR 2.0.50727; .NET CLR 3.0.30729)'
+      "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0; .NET4.0E; .NET4.0C; .NET CLR 3.5.30729; .NET CLR 2.0.50727; .NET CLR 3.0.30729)";
 
-    expect(utils.isIeOrEdge(userAgent)).toBe(true)
-  })
+    expect(utils.isIeOrEdge(userAgent)).toBe(true);
+  });
 
-  it('should return true for IE11', () => {
+  it("should return true for IE11", () => {
     const userAgent =
-      'Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; .NET4.0C; .NET4.0E; .NET CLR 2.0.50727; .NET CLR 3.0.30729; .NET CLR 3.5.30729; rv:11.0) like Gecko'
-    expect(utils.isIeOrEdge(userAgent)).toBe(true)
-  })
+      "Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; .NET4.0C; .NET4.0E; .NET CLR 2.0.50727; .NET CLR 3.0.30729; .NET CLR 3.5.30729; rv:11.0) like Gecko";
+    expect(utils.isIeOrEdge(userAgent)).toBe(true);
+  });
 
-  it('should return true for Edge', () => {
+  it("should return true for Edge", () => {
     const userAgent =
-      'Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36 Edge/16.16258'
+      "Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36 Edge/16.16258";
 
-    expect(utils.isIeOrEdge(userAgent)).toBe(true)
-  })
+    expect(utils.isIeOrEdge(userAgent)).toBe(true);
+  });
 
-  it('should return false for Chrome', () => {
+  it("should return false for Chrome", () => {
     const userAgent =
-      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.186 Safari/537.36'
+      "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.186 Safari/537.36";
 
-    expect(utils.isIeOrEdge(userAgent)).toBe(false)
-  })
-})
+    expect(utils.isIeOrEdge(userAgent)).toBe(false);
+  });
+});
 
-describe('isKindFile()', () => {
+describe("isKindFile()", () => {
   it('should return true for DataTransferItem of kind "file"', async () => {
-    const utils = await import('./index')
-    expect(utils.isKindFile({ kind: 'file' })).toBe(true)
-    expect(utils.isKindFile({ kind: 'text/html' })).toBe(false)
-    expect(utils.isKindFile({})).toBe(false)
-    expect(utils.isKindFile(null)).toBe(false)
-  })
-})
-
-describe('isPropagationStopped()', () => {
-  const trueFn = jest.fn(() => true)
-
-  let utils
+    const utils = await import("./index");
+    expect(utils.isKindFile({ kind: "file" })).toBe(true);
+    expect(utils.isKindFile({ kind: "text/html" })).toBe(false);
+    expect(utils.isKindFile({})).toBe(false);
+    expect(utils.isKindFile(null)).toBe(false);
+  });
+});
+
+describe("isPropagationStopped()", () => {
+  const trueFn = jest.fn(() => true);
+
+  let utils;
   beforeEach(async () => {
-    utils = await import('./index')
-  })
+    utils = await import("./index");
+  });
 
-  it('should return result of isPropagationStopped() if isPropagationStopped exists', () => {
-    expect(utils.isPropagationStopped({ isPropagationStopped: trueFn })).toBe(true)
-  })
+  it("should return result of isPropagationStopped() if isPropagationStopped exists", () => {
+    expect(utils.isPropagationStopped({ isPropagationStopped: trueFn })).toBe(
+      true
+    );
+  });
 
-  it('should return value of cancelBubble if isPropagationStopped doesnt exist and cancelBubble exists', () => {
-    expect(utils.isPropagationStopped({ cancelBubble: true })).toBe(true)
-  })
+  it("should return value of cancelBubble if isPropagationStopped doesnt exist and cancelBubble exists", () => {
+    expect(utils.isPropagationStopped({ cancelBubble: true })).toBe(true);
+  });
 
-  it('should return false if isPropagationStopped and cancelBubble are missing', () => {
-    expect(utils.isPropagationStopped({})).toBe(false)
-  })
-})
+  it("should return false if isPropagationStopped and cancelBubble are missing", () => {
+    expect(utils.isPropagationStopped({})).toBe(false);
+  });
+});
 
-describe('isEvtWithFiles()', () => {
-  let utils
+describe("isEvtWithFiles()", () => {
+  let utils;
   beforeEach(async () => {
-    utils = await import('./index')
-  })
+    utils = await import("./index");
+  });
 
-  it('should return true if some dragged types are files', () => {
-    expect(utils.isEvtWithFiles({ dataTransfer: { types: ['Files'] } })).toBe(true)
-    expect(utils.isEvtWithFiles({ dataTransfer: { types: ['application/x-moz-file'] } })).toBe(true)
+  it("should return true if some dragged types are files", () => {
+    expect(utils.isEvtWithFiles({ dataTransfer: { types: ["Files"] } })).toBe(
+      true
+    );
     expect(
       utils.isEvtWithFiles({
-        dataTransfer: { types: ['Files', 'application/x-moz-file'] }
+        dataTransfer: { types: ["application/x-moz-file"] },
       })
-    ).toBe(true)
-    expect(utils.isEvtWithFiles({ dataTransfer: { types: ['text/plain'] } })).toBe(false)
-    expect(utils.isEvtWithFiles({ dataTransfer: { types: ['text/html'] } })).toBe(false)
-    expect(utils.isEvtWithFiles({ dataTransfer: { types: ['Files', 'application/test'] } })).toBe(
-      true
-    )
+    ).toBe(true);
+    expect(
+      utils.isEvtWithFiles({
+        dataTransfer: { types: ["Files", "application/x-moz-file"] },
+      })
+    ).toBe(true);
+    expect(
+      utils.isEvtWithFiles({ dataTransfer: { types: ["text/plain"] } })
+    ).toBe(false);
+    expect(
+      utils.isEvtWithFiles({ dataTransfer: { types: ["text/html"] } })
+    ).toBe(false);
+    expect(
+      utils.isEvtWithFiles({
+        dataTransfer: { types: ["Files", "application/test"] },
+      })
+    ).toBe(true);
     expect(
       utils.isEvtWithFiles({
-        dataTransfer: { types: ['application/x-moz-file', 'application/test'] }
+        dataTransfer: { types: ["application/x-moz-file", "application/test"] },
       })
-    ).toBe(true)
-  })
+    ).toBe(true);
+  });
 
-  it('should return true if the event has a target with files', () => {
-    expect(utils.isEvtWithFiles({ target: { files: [] } })).toBe(true)
-  })
+  it("should return true if the event has a target with files", () => {
+    expect(utils.isEvtWithFiles({ target: { files: [] } })).toBe(true);
+  });
 
-  it('should return false otherwise', () => {
-    expect(utils.isEvtWithFiles({})).toBe(false)
-  })
-})
+  it("should return false otherwise", () => {
+    expect(utils.isEvtWithFiles({})).toBe(false);
+  });
+});
 
-describe('composeEventHandlers', () => {
-  let utils
+describe("composeEventHandlers", () => {
+  let utils;
   beforeEach(async () => {
-    utils = await import('./index')
-  })
-
-  it('returns a fn', () => {
-    const fn = utils.composeEventHandlers(() => {})
-    expect(typeof fn).toBe('function')
-  })
-
-  it('runs every passed fn in order', () => {
-    const fn1 = jest.fn()
-    const fn2 = jest.fn()
-    const fn = utils.composeEventHandlers(fn1, fn2)
-    const event = { type: 'click' }
-    const data = { ping: true }
-    fn(event, data)
-    expect(fn1).toHaveBeenCalledWith(event, data)
-    expect(fn2).toHaveBeenCalledWith(event, data)
-  })
-
-  it('stops after first fn that calls stopPropagation()', () => {
-    const fn1 = jest.fn().mockImplementation(event => {
-      Object.defineProperty(event, 'cancelBubble', { value: true })
-      return event
-    })
-    const fn2 = jest.fn()
-    const fn = utils.composeEventHandlers(fn1, fn2)
-    const event = new MouseEvent('click')
-    fn(event)
-    expect(fn1).toHaveBeenCalledWith(event)
-    expect(fn2).not.toHaveBeenCalled()
-  })
-
-  it('stops before first fn if bubble is already canceled', () => {
-    const fn1 = jest.fn()
-    const fn2 = jest.fn()
-    const fn = utils.composeEventHandlers(fn1, fn2)
-    const event = new MouseEvent('click')
-    Object.defineProperty(event, 'cancelBubble', { value: true })
-    fn(event)
-    expect(fn1).not.toHaveBeenCalled()
-    expect(fn2).not.toHaveBeenCalled()
-  })
-})
-
-describe('fileAccepted', () => {
-  let utils
+    utils = await import("./index");
+  });
+
+  it("returns a fn", () => {
+    const fn = utils.composeEventHandlers(() => {});
+    expect(typeof fn).toBe("function");
+  });
+
+  it("runs every passed fn in order", () => {
+    const fn1 = jest.fn();
+    const fn2 = jest.fn();
+    const fn = utils.composeEventHandlers(fn1, fn2);
+    const event = { type: "click" };
+    const data = { ping: true };
+    fn(event, data);
+    expect(fn1).toHaveBeenCalledWith(event, data);
+    expect(fn2).toHaveBeenCalledWith(event, data);
+  });
+
+  it("stops after first fn that calls stopPropagation()", () => {
+    const fn1 = jest.fn().mockImplementation((event) => {
+      Object.defineProperty(event, "cancelBubble", { value: true });
+      return event;
+    });
+    const fn2 = jest.fn();
+    const fn = utils.composeEventHandlers(fn1, fn2);
+    const event = new MouseEvent("click");
+    fn(event);
+    expect(fn1).toHaveBeenCalledWith(event);
+    expect(fn2).not.toHaveBeenCalled();
+  });
+
+  it("stops before first fn if bubble is already canceled", () => {
+    const fn1 = jest.fn();
+    const fn2 = jest.fn();
+    const fn = utils.composeEventHandlers(fn1, fn2);
+    const event = new MouseEvent("click");
+    Object.defineProperty(event, "cancelBubble", { value: true });
+    fn(event);
+    expect(fn1).not.toHaveBeenCalled();
+    expect(fn2).not.toHaveBeenCalled();
+  });
+});
+
+describe("fileAccepted", () => {
+  let utils;
   beforeEach(async () => {
-    utils = await import('./index')
-  })
-
-  it('accepts bogus firefox file', () => {
-    const file = createFile('bogus.png', 100, 'application/x-moz-file');
-    expect(utils.fileAccepted(file, '.pdf')).toEqual([true, null])
-  })
-
-  it('accepts file when single accept criteria', () => {
-    const file = createFile('hamster.pdf', 100, 'application/pdf');
-    expect(utils.fileAccepted(file, '.pdf')).toEqual([true, null])
-  })
-
-  it('accepts file when multiple accept criteria', () => {
-    const file = createFile('hamster.pdf', 100, 'application/pdf');
-    expect(utils.fileAccepted(file, ['.pdf', '.png'])).toEqual([true, null])
-  })
-
-  it('rejects file when single accept criteria', () => {
-    const file = createFile('hamster.pdf', 100, 'application/pdf');
-    expect(utils.fileAccepted(file, '.png')).toEqual([false, { code: 'file-invalid-type', message: 'File type must be .png' }])
-  })
-
-  it('rejects file when multiple accept criteria', () => {
-    const file = createFile('hamster.pdf', 100, 'application/pdf');
-    expect(utils.fileAccepted(file, ['.gif', '.png'])).toEqual([false, { code: 'file-invalid-type', message: 'File type must be one of .gif, .png' }])
-  })
-
-it('rejects file when single accept criteria as array', () => {
-  const file = createFile('hamster.pdf', 100, 'application/pdf');
-  expect(utils.fileAccepted(file, ['.gif'])).toEqual([false, { code: 'file-invalid-type', message: 'File type must be .gif' }])
-})
-
-})
-
-describe('allFilesAccepted()', () => {
-  let utils
+    utils = await import("./index");
+  });
+
+  it("accepts bogus firefox file", () => {
+    const file = createFile("bogus.png", 100, "application/x-moz-file");
+    expect(utils.fileAccepted(file, ".pdf")).toEqual([true, null]);
+  });
+
+  it("accepts file when single accept criteria", () => {
+    const file = createFile("hamster.pdf", 100, "application/pdf");
+    expect(utils.fileAccepted(file, ".pdf")).toEqual([true, null]);
+  });
+
+  it("accepts file when multiple accept criteria", () => {
+    const file = createFile("hamster.pdf", 100, "application/pdf");
+    expect(utils.fileAccepted(file, [".pdf", ".png"])).toEqual([true, null]);
+  });
+
+  it("rejects file when single accept criteria", () => {
+    const file = createFile("hamster.pdf", 100, "application/pdf");
+    expect(utils.fileAccepted(file, ".png")).toEqual([
+      false,
+      { code: "file-invalid-type", message: "File type must be .png" },
+    ]);
+  });
+
+  it("rejects file when multiple accept criteria", () => {
+    const file = createFile("hamster.pdf", 100, "application/pdf");
+    expect(utils.fileAccepted(file, [".gif", ".png"])).toEqual([
+      false,
+      {
+        code: "file-invalid-type",
+        message: "File type must be one of .gif, .png",
+      },
+    ]);
+  });
+
+  it("rejects file when single accept criteria as array", () => {
+    const file = createFile("hamster.pdf", 100, "application/pdf");
+    expect(utils.fileAccepted(file, [".gif"])).toEqual([
+      false,
+      { code: "file-invalid-type", message: "File type must be .gif" },
+    ]);
+  });
+});
+
+describe("allFilesAccepted()", () => {
+  let utils;
   beforeEach(async () => {
-    utils = await import('./index')
-  })
-  it('rejects file when multiple accept criteria', () => {
-    const files = [createFile('hamster.pdf', 100, 'application/pdf'),createFile('fish.pdf', 100, 'application/pdf')];
-    const images = [createFile('cats.gif', 1234, 'image/gif'), createFile('dogs.gif', 2345, 'image/jpeg')]
-    expect(utils.allFilesAccepted({ files, multiple: true})).toEqual(true)
-    expect(utils.allFilesAccepted({ files, multiple: true, maxFiles: 10 })).toEqual(true)
-    expect(utils.allFilesAccepted({ files, multiple: false, maxFiles: 10 })).toEqual(false)
-    expect(utils.allFilesAccepted({ files, multiple: true, accept:'image/jpeg' })).toEqual(false)
-    expect(utils.allFilesAccepted({ files: images, multiple: true,accept:'image/*' })).toEqual(true)
-    expect(utils.allFilesAccepted({ files, multiple: true, minSize: 110 })).toEqual(false)
-    expect(utils.allFilesAccepted({ files, multiple: true, maxSize: 99 })).toEqual(false)
-    expect(utils.allFilesAccepted({ files, multiple: true, maxFiles: 1 })).toEqual(false)
-  })
-})
-
-describe('ErrorCode', () => {
-  let utils
+    utils = await import("./index");
+  });
+  it("rejects file when multiple accept criteria", () => {
+    const files = [
+      createFile("hamster.pdf", 100, "application/pdf"),
+      createFile("fish.pdf", 100, "application/pdf"),
+    ];
+    const images = [
+      createFile("cats.gif", 1234, "image/gif"),
+      createFile("dogs.gif", 2345, "image/jpeg"),
+    ];
+    expect(utils.allFilesAccepted({ files, multiple: true })).toEqual(true);
+    expect(
+      utils.allFilesAccepted({ files, multiple: true, maxFiles: 10 })
+    ).toEqual(true);
+    expect(
+      utils.allFilesAccepted({ files, multiple: false, maxFiles: 10 })
+    ).toEqual(false);
+    expect(
+      utils.allFilesAccepted({ files, multiple: true, accept: "image/jpeg" })
+    ).toEqual(false);
+    expect(
+      utils.allFilesAccepted({
+        files: images,
+        multiple: true,
+        accept: "image/*",
+      })
+    ).toEqual(true);
+    expect(
+      utils.allFilesAccepted({ files, multiple: true, minSize: 110 })
+    ).toEqual(false);
+    expect(
+      utils.allFilesAccepted({ files, multiple: true, maxSize: 99 })
+    ).toEqual(false);
+    expect(
+      utils.allFilesAccepted({ files, multiple: true, maxFiles: 1 })
+    ).toEqual(false);
+  });
+});
+
+describe("ErrorCode", () => {
+  let utils;
   beforeEach(async () => {
-    utils = await import('./index')
-  })
-
-  it('should exist and have known error code properties', () => {
-    expect(utils.ErrorCode.FileInvalidType).toEqual(utils.FILE_INVALID_TYPE)
-    expect(utils.ErrorCode.FileTooLarge).toEqual(utils.FILE_TOO_LARGE)
-    expect(utils.ErrorCode.FileTooSmall).toEqual(utils.FILE_TOO_SMALL)
-    expect(utils.ErrorCode.TooManyFiles).toEqual(utils.TOO_MANY_FILES)
-  })
-})
-
-describe('canUseFileSystemAccessAPI()', () => {
-  let utils
+    utils = await import("./index");
+  });
+
+  it("should exist and have known error code properties", () => {
+    expect(utils.ErrorCode.FileInvalidType).toEqual(utils.FILE_INVALID_TYPE);
+    expect(utils.ErrorCode.FileTooLarge).toEqual(utils.FILE_TOO_LARGE);
+    expect(utils.ErrorCode.FileTooSmall).toEqual(utils.FILE_TOO_SMALL);
+    expect(utils.ErrorCode.TooManyFiles).toEqual(utils.TOO_MANY_FILES);
+  });
+});
+
+describe("canUseFileSystemAccessAPI()", () => {
+  let utils;
   beforeEach(async () => {
-    utils = await import('./index')
-  })
+    utils = await import("./index");
+  });
 
-  it('should return false if not', () => {
-    expect(utils.canUseFileSystemAccessAPI()).toBe(false)
-  })
+  it("should return false if not", () => {
+    expect(utils.canUseFileSystemAccessAPI()).toBe(false);
+  });
 
-  it('should return true if yes', () => {
+  it("should return true if yes", () => {
     // TODO: If we use these in other tests, restore once test is done
-    window.showOpenFilePicker = jest.fn()
-    expect(utils.canUseFileSystemAccessAPI()).toBe(true)
-  })
-})
+    window.showOpenFilePicker = jest.fn();
+    expect(utils.canUseFileSystemAccessAPI()).toBe(true);
+  });
+});
 
-describe('filePickerOptionsTypes()', () => {
-  let utils
+describe("filePickerOptionsTypes()", () => {
+  let utils;
   beforeEach(async () => {
-    utils = await import('./index')
-  })
-
-  it('should return proper types when the arg is a MIME type', () => {
-    expect(utils.filePickerOptionsTypes('application/zip')).toEqual([{
-      description: 'everything',
-      accept: {'application/zip': []}
-    }])
-  })
-
-  it('should return proper types when the arg is an array of MIME types', () => {
-    expect(utils.filePickerOptionsTypes(['application/zip', 'application/json'])).toEqual([{
-      description: 'everything',
-      accept: {
-        'application/zip': [],
-        'application/json': []
-      }
-    }])
-  })
+    utils = await import("./index");
+  });
+
+  it("should return proper types when the arg is a MIME type", () => {
+    expect(utils.filePickerOptionsTypes("application/zip")).toEqual([
+      {
+        description: "everything",
+        accept: { "application/zip": [] },
+      },
+    ]);
+  });
+
+  it("should return proper types when the arg is an array of MIME types", () => {
+    expect(
+      utils.filePickerOptionsTypes(["application/zip", "application/json"])
+    ).toEqual([
+      {
+        description: "everything",
+        accept: {
+          "application/zip": [],
+          "application/json": [],
+        },
+      },
+    ]);
+  });
 
   it("should exclude anything that's not a MIME type", () => {
-    expect(utils.filePickerOptionsTypes(['audio/*', 'video/*', 'image/*', '.txt', 'text/*'])).toEqual([{
-      description: 'everything',
-      accept: {
-        'audio/*': [],
-        'video/*': [],
-        'image/*': [],
-        'text/*': [],
-      }
-    }])
-  })
+    expect(
+      utils.filePickerOptionsTypes([
+        "audio/*",
+        "video/*",
+        "image/*",
+        ".txt",
+        "text/*",
+      ])
+    ).toEqual([
+      {
+        description: "everything",
+        accept: {
+          "audio/*": [],
+          "video/*": [],
+          "image/*": [],
+          "text/*": [],
+        },
+      },
+    ]);
+  });
 
   it("should work with comma separated string of MIME types", () => {
-    expect(utils.filePickerOptionsTypes('audio/*,video/*,image/*,.txt,text/*,application/zip')).toEqual([{
-      description: 'everything',
-      accept: {
-        'audio/*': [],
-        'video/*': [],
-        'image/*': [],
-        'text/*': [],
-        'application/zip': []
-      }
-    }])
-  })
-
-  it('should return empty otherwise', () => {
-    expect(utils.filePickerOptionsTypes('')).toEqual([{
-      description: 'everything',
-      accept: {}
-    }])
-  })
-})
+    expect(
+      utils.filePickerOptionsTypes(
+        "audio/*,video/*,image/*,.txt,text/*,application/zip"
+      )
+    ).toEqual([
+      {
+        description: "everything",
+        accept: {
+          "audio/*": [],
+          "video/*": [],
+          "image/*": [],
+          "text/*": [],
+          "application/zip": [],
+        },
+      },
+    ]);
+  });
+
+  it("should return empty otherwise", () => {
+    expect(utils.filePickerOptionsTypes("")).toEqual([
+      {
+        description: "everything",
+        accept: {},
+      },
+    ]);
+  });
+});
 
 function createFile(name, size, type) {
-  const file = new File([], name, { type })
-  Object.defineProperty(file, 'size', {
+  const file = new File([], name, { type });
+  Object.defineProperty(file, "size", {
     get() {
-      return size
-    }
-  })
-  return file
+      return size;
+    },
+  });
+  return file;
 }