passbolt-browser-extension 3.0.6 → 4.6.2

package/src/all/background_page/service/webIntegration/parseWebIntegrationUrlService.js

@@ -0,0 +1,44 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2023 Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) 2023 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.10.0
+ */
+import User from "../../model/user";
+
+class ParseWebIntegrationUrlService {
+  /**
+   * Get regex to check URI validity
+   * @returns {RegExp}
+   */
+  static get regex() {
+    const user = User.getInstance();
+    const escapedDomain = user.settings.getDomain().replace(/\W/g, "\\$&");
+    // Regex to check this is not our domain or chrome and about page
+    return new RegExp(`^(?!(${escapedDomain}|chrome:|about:|https:\/\/(www\.passbolt|mail\.google)\.com)).*$`);
+  }
+
+  /**
+   * Test regex with the url.
+   * @param {string} url The url to test.
+   * @returns {boolean}
+   */
+  static test(url) {
+    try {
+      // Check if the url is valid
+      new URL(url);
+      return this.regex.test(url);
+    } catch (error) {
+      return false;
+    }
+  }
+}
+
+export default ParseWebIntegrationUrlService;

package/src/all/background_page/service/webIntegration/parseWebIntegrationUrlService.test.js

@@ -0,0 +1,56 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) 2023 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.10.0
+ */
+
+import each from "jest-each";
+import ParseWebIntegrationUrlService from "./parseWebIntegrationUrlService";
+import {Config} from "../../model/config";
+
+describe("ParseWebIntegrationUrlService", () => {
+  const domain = "https://passbolt.dev";
+
+  beforeEach(() => {
+    Config.write("user.settings.trustedDomain", domain);
+  });
+
+  describe("ParseWebIntegrationUrlService:test", () => {
+    each([
+      {scenario: "Web page", url: "https://test.com/auth/login"},
+      {scenario: "Web page with parameters", url: "https://test.com/auth/login?locale=en-UK"},
+      {scenario: "Web page with anchors", url: "https://test.com/auth/login#test"},
+      {scenario: "Web page with no domain", url: "https://auth/login"},
+    ]).describe("should parse", _props => {
+      it(`should match: ${_props.scenario}`, () => {
+        const parseResult = ParseWebIntegrationUrlService.test(_props.url);
+        expect.assertions(1);
+        expect(parseResult).toBeTruthy();
+      });
+    });
+
+    each([
+      {scenario: "No protocol given", url: "passbolt.dev/auth/login"},
+      {scenario: "Passbolt domain", url: domain},
+      {scenario: "Chrome page", url: "chrome://settings/"},
+      {scenario: "Blank page", url: "about:blank"},
+      {scenario: "Config page", url: "about:config"},
+      {scenario: "Passbolt page", url: "https://www.passbolt.com/"},
+      {scenario: "gmail page", url: "https://mail.google.com/"}
+    ]).describe("should not parse", _props => {
+      it(`should not match: ${_props.scenario}`, () => {
+        const parseResult = ParseWebIntegrationUrlService.test(_props.url);
+        expect.assertions(1);
+        expect(parseResult).toBeFalsy();
+      });
+    });
+  });
+});

package/src/all/background_page/service/webNavigation/webNavigationService.js

@@ -0,0 +1,33 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2023 Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) 2023 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.0.0
+ */
+import PortManager from "../../sdk/port/portManager";
+import PagemodManager from "../../pagemod/pagemodManager";
+
+class WebNavigationService {
+  /**
+   * Execute the navigation service process
+   * @param frameDetails
+   * @returns {Promise<void>}
+   */
+  static async exec(frameDetails) {
+    // Remove port and worker in session storage if the user navigate
+    if (frameDetails.frameId === 0) {
+      await PortManager.onTabRemoved(frameDetails.tabId);
+    }
+    // Process to detect a pagemod and inject CSS, JS files
+    await PagemodManager.exec(frameDetails);
+  }
+}
+
+export default WebNavigationService;

package/src/all/background_page/service/webNavigation/webNavigationService.test.js

@@ -0,0 +1,58 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2023 Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) 2023 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.0.0
+ */
+import PortManager from "../../sdk/port/portManager";
+import PagemodManager from "../../pagemod/pagemodManager";
+import WebNavigationService from "./webNavigationService";
+
+jest.spyOn(PortManager, "onTabRemoved");
+jest.spyOn(PagemodManager, "exec");
+
+describe("NavigationService", () => {
+  beforeEach(async() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+  });
+
+  describe("NavigationService::exec", () => {
+    it("Should remove port and exec pagemod manager", async() => {
+      expect.assertions(2);
+      // data mocked
+      const frameDetails = {
+        url: "https://localhost",
+        tabId: 1234,
+        frameId: 0
+      };
+      // process
+      await WebNavigationService.exec(frameDetails);
+      // expectations
+      expect(PortManager.onTabRemoved).toHaveBeenCalledWith(frameDetails.tabId);
+      expect(PagemodManager.exec).toHaveBeenCalledWith(frameDetails);
+    });
+
+    it("Should only exec pagemod manager", async() => {
+      expect.assertions(2);
+      // data mocked
+      const frameDetails = {
+        url: "https://localhost",
+        tabId: 1234,
+        frameId: 1234
+      };
+      // process
+      await WebNavigationService.exec(frameDetails);
+      // expectations
+      expect(PortManager.onTabRemoved).not.toHaveBeenCalled();
+      expect(PagemodManager.exec).toHaveBeenCalledWith(frameDetails);
+    });
+  });
+});

package/src/all/background_page/service/worker/workerService.js

@@ -0,0 +1,146 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.0.0
+ */
+import {v4 as uuid} from "uuid";
+import PortManager from "../../sdk/port/portManager";
+import WorkersSessionStorage from "../sessionStorage/workersSessionStorage";
+import BrowserTabService from "../ui/browserTab.service";
+import WorkerEntity from "../../model/entity/worker/workerEntity";
+import WebNavigationService from "../webNavigation/webNavigationService";
+
+const WORKER_EXIST_ALARM = "WorkerExistFlush";
+const WORKER_EXIST_ALARM_TIME_CHECKING = 100;
+const WORKER_CHECK_STATUS_ALARM = 'workerId-';
+const WORKER_CHECK_STATUS_ALARM_TIME_CHECKING = 50;
+
+class WorkerService {
+  /**
+   *
+   * Get the worker according to the application name and tab id
+   *
+   * @param {string} applicationName The application name
+   * @param {number} tabId The tab id
+   * @returns {Promise<Worker>} The worker
+   */
+  static async get(applicationName, tabId) {
+    const workers = await WorkersSessionStorage.getWorkersByNameAndTabId(applicationName, tabId);
+    if (workers.length === 0) {
+      throw new Error(`Could not find worker ${applicationName} for tab ${tabId}.`);
+    }
+    // Get only the first worker
+    const worker = workers[0];
+    if (!PortManager.isPortExist(worker.id)) {
+      await BrowserTabService.sendMessage(worker, "passbolt.port.connect", worker.id);
+    }
+    const port = await PortManager.getPortById(worker.id);
+    const tab = port._port.sender.tab;
+    return {port, tab};
+  }
+
+  /**
+   * Wait until a worker exists
+   * @param {string} applicationName The application name
+   * @param {number} tabId The tab identifier on which the worker runs
+   * @param {int} timeout The timeout after which the promise fails if the worker is not found
+   * @return {Promise<void>}
+   */
+  static waitExists(applicationName, tabId, timeout = 10000) {
+    const timeoutMs = Date.now() + timeout;
+    const alarmName = `${WORKER_EXIST_ALARM}-${uuid()}`;
+    return new Promise((resolve, reject) => {
+      const handleWorkerExist = async alarm => {
+        if (alarm.name === alarmName) {
+          try {
+            this.clearAlarm(alarmName, handleWorkerExist);
+            await this.get(applicationName, tabId);
+            resolve();
+          } catch (error) {
+            if (alarm.scheduledTime >= timeoutMs) {
+              reject(error);
+            } else {
+              this.createAlarm(alarmName, WORKER_EXIST_ALARM_TIME_CHECKING, handleWorkerExist);
+            }
+          }
+        }
+      };
+      this.createAlarm(alarmName, WORKER_EXIST_ALARM_TIME_CHECKING, handleWorkerExist);
+    });
+  }
+
+  /**
+   * Clear and create alarm to execute a navigation for worker which are waiting for connection
+   * @params {WorkerEntity} The worker entity
+   * @returns {Promise<void>}
+   */
+  static async checkAndExecNavigationForWorkerWaitingConnection(workerEntity) {
+    const alarmName = `${WORKER_CHECK_STATUS_ALARM}${workerEntity.id}`;
+    await this.clearAlarm(alarmName, this.execNavigationForWorkerWaitingConnection);
+    await this.createAlarm(alarmName, WORKER_CHECK_STATUS_ALARM_TIME_CHECKING, this.execNavigationForWorkerWaitingConnection);
+  }
+
+  /**
+   * Create alarm
+   * @param {string} alarmName The alarm name
+   * @param {number} timeInMs The time when the alarm fire
+   * @param {function} handleAlarmEvent The function on alarm listener
+   */
+  static createAlarm(alarmName, timeInMs, handleAlarmEvent) {
+    // Create an alarm to check if the worker exist
+    browser.alarms.create(alarmName, {
+      when: Date.now() + timeInMs
+    });
+    browser.alarms.onAlarm.addListener(handleAlarmEvent);
+  }
+
+  /**
+   * Clear the alarm and listener configured.
+   * @param {string} alarmName The alarm name
+   * @param {function} handleAlarmEvent The function on alarm listener
+   */
+  static clearAlarm(alarmName, handleAlarmEvent) {
+    browser.alarms.onAlarm.removeListener(handleAlarmEvent);
+    browser.alarms.clear(alarmName);
+  }
+
+  /**
+   * Exec a navigation for worker block in waiting connection status
+   * @private
+   * @param {Object} alarm
+   * @return {Promise<void>}
+   */
+  static async execNavigationForWorkerWaitingConnection(alarm) {
+    if (alarm.name.startsWith(WORKER_CHECK_STATUS_ALARM)) {
+      const workerId = alarm.name.substring(WORKER_CHECK_STATUS_ALARM.length);
+      const worker = await WorkersSessionStorage.getWorkerById(workerId);
+      if (!worker) {
+        console.debug("No worker has been found");
+        return;
+      }
+      const workerEntity = new WorkerEntity(worker);
+      if (workerEntity.isWaitingConnection) {
+        // Get the tab information by tab id to have the last url in case of redirection
+        const tab = await BrowserTabService.getById(workerEntity.tabId);
+        // Execute the process of a web navigation to detect pagemod and script to insert
+        const frameDetails = {
+          // Mapping the tab info as a frame details to be compliant with webNavigation API
+          frameId: 0,
+          tabId: worker.tabId,
+          url: tab.url
+        };
+        await WebNavigationService.exec(frameDetails);
+      }
+    }
+  }
+}
+
+export default WorkerService;

package/src/all/background_page/service/worker/workerService.test.js

@@ -0,0 +1,191 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.0.0
+ */
+import PortManager from "../../sdk/port/portManager";
+import WorkerService from "./workerService";
+import BrowserTabService from "../ui/browserTab.service";
+import WorkersSessionStorage from "../sessionStorage/workersSessionStorage";
+import {readWorker} from "../../model/entity/worker/workerEntity.test.data";
+import WorkerEntity from "../../model/entity/worker/workerEntity";
+import WebNavigationService from "../webNavigation/webNavigationService";
+
+describe("WorkerService", () => {
+  beforeEach(() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+    jest.clearAllTimers();
+    jest.useFakeTimers();
+  });
+
+  describe("WorkerService::get", () => {
+    it("Should get worker", async() => {
+      expect.assertions(3);
+      // data mocked
+      const worker = readWorker();
+      const port = {
+        _name: worker.id,
+        _port: {
+          sender: {
+            tab: {}
+          }
+        }
+      };
+      // mock functions
+      jest.spyOn(WorkersSessionStorage, 'getWorkersByNameAndTabId').mockImplementationOnce(() => [worker]);
+      jest.spyOn(BrowserTabService, "sendMessage").mockImplementationOnce(() => jest.fn());
+      jest.spyOn(PortManager, "getPortById").mockImplementationOnce(() => port);
+      // process
+      const workerResult = await WorkerService.get("ApplicationName", 1);
+      // expectations
+      expect(BrowserTabService.sendMessage).toHaveBeenCalledWith(worker, "passbolt.port.connect", worker.id);
+      expect(PortManager.getPortById).toHaveBeenCalledWith(worker.id);
+      expect(workerResult).toStrictEqual({port: port, tab: port._port.sender.tab});
+    });
+
+    it("Should get no worker", async() => {
+      expect.assertions(3);
+      // mock functions
+      jest.spyOn(WorkersSessionStorage, 'getWorkersByNameAndTabId').mockImplementationOnce(() => []);
+      jest.spyOn(BrowserTabService, "sendMessage");
+      jest.spyOn(PortManager, "getPortById");
+      // process
+      try {
+        await WorkerService.get("ApplicationName", 1);
+      } catch (error) {
+        // expectations
+        expect(BrowserTabService.sendMessage).not.toHaveBeenCalled();
+        expect(PortManager.getPortById).not.toHaveBeenCalled();
+        expect(error).toStrictEqual(new Error("Could not find worker ApplicationName for tab 1."));
+      }
+    });
+  });
+
+  describe("WorkerService::waitExists", () => {
+    it("should wait for the worker exists", async() => {
+      expect.assertions(10);
+      // data mocked
+      const worker = readWorker({name: "QuickAccess"});
+      const port = {
+        _name: worker.id,
+        _port: {
+          sender: {
+            tab: worker.tabId
+          }
+        }
+      };
+      // mock functions
+      jest.spyOn(PortManager, "getPortById").mockImplementation(() => port);
+      const spy = jest.spyOn(WorkerService, "waitExists");
+      const spyOnAlarmClear = jest.spyOn(browser.alarms, "clear");
+      const spyOnAlarmCreate = jest.spyOn(browser.alarms, "create");
+
+      expect(spy).not.toHaveBeenCalled();
+
+      WorkerService.waitExists("QuickAccess", worker.tabId);
+      expect(spy).toHaveBeenCalledTimes(1);
+      expect(spyOnAlarmCreate).toHaveBeenCalledTimes(1);
+      expect(spyOnAlarmClear).toHaveBeenCalledTimes(0);
+
+      jest.advanceTimersByTime(101);
+      await WorkersSessionStorage.addWorker(new WorkerEntity(worker));
+      expect(spy).toHaveBeenCalledTimes(1);
+      expect(spyOnAlarmCreate).toHaveBeenCalledTimes(2);
+      expect(spyOnAlarmClear).toHaveBeenCalledTimes(1);
+
+      jest.advanceTimersByTime(100);
+      expect(spy).toHaveBeenCalledTimes(1);
+      expect(spyOnAlarmCreate).toHaveBeenCalledTimes(2);
+      expect(spyOnAlarmClear).toHaveBeenCalledTimes(2);
+    });
+
+    it("should raise an error if the worker not exists until timeout", async() => {
+      expect.assertions(8);
+      const spy = jest.spyOn(WorkerService, "waitExists");
+      jest.spyOn(WorkerService, "get").mockImplementation(() => { throw new Error("Could not find worker ID QuickAccess for tab 1."); });
+      const spyOnAlarmClear = jest.spyOn(browser.alarms, "clear");
+      const spyOnAlarmCreate = jest.spyOn(browser.alarms, "create");
+
+      expect(spy).not.toHaveBeenCalled();
+
+      WorkerService.waitExists("QuickAccess", 1).catch(error => {
+        expect(error.message).toBe("Could not find worker ID QuickAccess for tab 1.");
+      });
+
+      expect(spy).toHaveBeenCalledTimes(1);
+      expect(spyOnAlarmCreate).toHaveBeenCalledTimes(1);
+      expect(spyOnAlarmClear).toHaveBeenCalledTimes(0);
+
+      jest.advanceTimersByTime(20000);
+      expect(spy).toHaveBeenCalledTimes(1);
+      expect(spyOnAlarmCreate).toHaveBeenCalledTimes(100);
+      expect(spyOnAlarmClear).toHaveBeenCalledTimes(100);
+    });
+  });
+
+  describe("WorkerService::checkAndExecNavigationForWorkerWaitingConnection", () => {
+    it("Exec a navigation", async() => {
+      expect.assertions(3);
+
+      const dto = readWorker({status: WorkerEntity.STATUS_WAITING_CONNECTION});
+
+      jest.spyOn(WorkersSessionStorage, "getWorkerById").mockImplementationOnce(() => dto);
+      jest.spyOn(BrowserTabService, "getById").mockImplementationOnce(() => ({url: "https://url.com"}));
+      jest.spyOn(WebNavigationService, "exec");
+
+      const frameDetails = {
+        url: "https://url.com",
+        tabId: dto.tabId,
+        frameId: 0
+      };
+      const entity = new WorkerEntity(dto);
+      await WorkerService.checkAndExecNavigationForWorkerWaitingConnection(entity);
+      // start the alarm
+      jest.advanceTimersByTime(50);
+      await Promise.resolve();
+      await Promise.resolve();
+      expect(entity.toDto()).toEqual(dto);
+      expect(BrowserTabService.getById).toHaveBeenCalledWith(dto.tabId);
+      expect(WebNavigationService.exec).toHaveBeenCalledWith(frameDetails);
+    });
+
+    it("Should not exec a navigation if the worker is connected", async() => {
+      expect.assertions(2);
+      const dto = readWorker();
+
+      jest.spyOn(WorkersSessionStorage, "getWorkerById").mockImplementationOnce(() => dto);
+      jest.spyOn(WebNavigationService, "exec");
+
+      const entity = new WorkerEntity(dto);
+      await WorkerService.checkAndExecNavigationForWorkerWaitingConnection(entity);
+      // start the alarm
+      jest.advanceTimersByTime(50);
+      expect(entity.toDto()).toEqual(dto);
+      expect(WebNavigationService.exec).not.toHaveBeenCalled();
+    });
+
+    it("Should not exec a navigation if the worker is not found", async() => {
+      expect.assertions(2);
+      const dto = readWorker();
+
+      jest.spyOn(WorkersSessionStorage, "getWorkerById").mockImplementationOnce(() => undefined);
+      jest.spyOn(WebNavigationService, "exec");
+
+      const entity = new WorkerEntity(dto);
+      await WorkerService.checkAndExecNavigationForWorkerWaitingConnection(entity);
+      // start the alarm
+      jest.advanceTimersByTime(50);
+      expect(entity.toDto()).toEqual(dto);
+      expect(WebNavigationService.exec).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/all/background_page/utils/array/deduplicateObjects.js

@@ -31,27 +31,27 @@ const deduplicateObjects = (arr, key) => {
 
   // Extract the values to deduplicate in an hashtable.
   const valuesHash = arr
-    // Do not add to the hash the object which doesn't have the property.
-    .filter(row => row.hasOwnProperty(key))
-    .map(row => row[key])
+  // Do not add to the hash the object which doesn't have the property.
+    .filter(row => Object.prototype.hasOwnProperty.call(row, key))
+    .map(row => row[key]);
 
   /**
    * Deduplicate the values by flipping the hash table.
    * By instance: ["ID-1", "ID-2", "ID-1"] will become ["ID-1": 0, "ID-2": 1]
    */
   const deduplicatedValuesMap = valuesHash.reduce((aggregator, value, index) => {
-    aggregator[value] = aggregator.hasOwnProperty(value) ? aggregator[value] : index;
-    return aggregator
+    aggregator[value] = Object.prototype.hasOwnProperty.call(aggregator, value) ? aggregator[value] : index;
+    return aggregator;
   }, {});
 
   // Deduplicate the array of objects based on the deduplicated values map.
   return arr.filter((row, index) => {
     // Deduplicate only objects which have the property of interest.
-    if (row.hasOwnProperty(key)) {
-      return deduplicatedValuesMap[row[key]] === index
+    if (Object.prototype.hasOwnProperty.call(row, key)) {
+      return deduplicatedValuesMap[row[key]] === index;
     }
     return true;
   });
 };
 
-exports.deduplicateObjects = deduplicateObjects;
+export default deduplicateObjects;

package/src/all/background_page/utils/array/deduplicateObjects.test.js

@@ -11,32 +11,32 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         3.0.4
  */
-const {deduplicateObjects} = require("./deduplicateObjects");
+import deduplicateObjects from "./deduplicateObjects";
 
 describe("deduplicateObjects", () => {
   it("deduplicate array of objects", () => {
-    const arr = [{prop:1}, {prop:2}, {prop:1}, {prop:2}]
+    const arr = [{prop: 1}, {prop: 2}, {prop: 1}, {prop: 2}];
     const dedupArr = deduplicateObjects(arr, 'prop');
     expect(dedupArr).toHaveLength(2);
-    expect(dedupArr).toEqual(expect.arrayContaining([{prop:1}, {prop:2}]));
+    expect(dedupArr).toEqual(expect.arrayContaining([{prop: 1}, {prop: 2}]));
   });
 
   it("deduplicate array of objects with object not having the property of interest, should return the object not having this property", () => {
-    const arr = [{prop:1}, {prop:2}, {noi_prop:1}, {noi_prop:2}]
+    const arr = [{prop: 1}, {prop: 2}, {noi_prop: 1}, {noi_prop: 2}];
     const dedupArr = deduplicateObjects(arr, 'prop');
     expect(dedupArr).toHaveLength(4);
-    expect(dedupArr).toEqual(expect.arrayContaining([{prop:1}, {prop:2}, {noi_prop:1}, {noi_prop:2}]));
+    expect(dedupArr).toEqual(expect.arrayContaining([{prop: 1}, {prop: 2}, {noi_prop: 1}, {noi_prop: 2}]));
   });
 
   it("deduplicate array of objects even with not of interest different properties, should return the first occurrence found", () => {
-    const arr = [{prop:1, noi_prop: 1}, {prop:2, noi_prop: 2}, {prop:1, noi_prop: 3}, {prop:2, noi_prop: 4}]
+    const arr = [{prop: 1, noi_prop: 1}, {prop: 2, noi_prop: 2}, {prop: 1, noi_prop: 3}, {prop: 2, noi_prop: 4}];
     const dedupArr = deduplicateObjects(arr, 'prop');
     expect(dedupArr).toHaveLength(2);
-    expect(dedupArr).toEqual(expect.arrayContaining([{prop:1, noi_prop: 1}, {prop:2, noi_prop: 2}]));
+    expect(dedupArr).toEqual(expect.arrayContaining([{prop: 1, noi_prop: 1}, {prop: 2, noi_prop: 2}]));
   });
 
   it("deduplicate array of scalar should return all the values present in the original array", () => {
-    const arr = [1, 2, 3]
+    const arr = [1, 2, 3];
     const dedupArr = deduplicateObjects(arr, 'prop');
     expect(dedupArr).toHaveLength(3);
     expect(dedupArr).toEqual(expect.arrayContaining(arr));
@@ -45,11 +45,11 @@ describe("deduplicateObjects", () => {
   it("deduplicate with unsupported first parameter should throw an error", () => {
     const scenarios = {
       "null": null,
-      "object": {prop:1},
+      "object": {prop: 1},
       "scalar": "string"
     };
 
-    for (let scenario in scenarios) {
+    for (const scenario in scenarios) {
       try {
         deduplicateObjects(scenarios[scenario], 'prop');
         expect(true).toBeFalsy();
@@ -62,13 +62,13 @@ describe("deduplicateObjects", () => {
   it("deduplicate with unsupported second parameter should throw an error", () => {
     const scenarios = {
       "null": null,
-      "object": {prop:1},
+      "object": {prop: 1},
       "integer": 10
     };
 
-    for (let scenario in scenarios) {
+    for (const scenario in scenarios) {
       try {
-        deduplicateObjects([{prop:1}, {prop:2}], scenarios[scenario]);
+        deduplicateObjects([{prop: 1}, {prop: 2}], scenarios[scenario]);
         expect(true).toBeFalsy();
       } catch (error) {
         expect(error).toBeInstanceOf(TypeError);

package/src/all/background_page/utils/array/splitBySize.js

@@ -24,6 +24,6 @@ const splitBySize = (arr, size) => arr.reduce((chunks, el, i) => {
     chunks.push([el]);
   }
   return chunks;
-}, [])
+}, []);
 
-exports.splitBySize = splitBySize;
+export default splitBySize;