Migrate to typescript in full monorepo

.github/workflows/mobile-test.yml

@@ -4,10 +4,10 @@ on:
     branches:
       - main
     paths:
-      - "mobile/**"
+      - "packages/lesspass-mobile/**"
   pull_request:
     paths:
-      - "mobile/**"
+      - "packages/lesspass-mobile/**"
 jobs:
   test-mobile:
     runs-on: ubuntu-18.04
@@ -17,6 +17,6 @@ jobs:
         with:
           node-version: "14"
       - run: |
-          cd mobile
+          cd packages/lesspass-mobile
           yarn install
           yarn test

.gitignore

@@ -6,7 +6,5 @@ node_modules
 package-lock.json
 default.nix
 .envrc
-sandbox/lesspass-passwordrules
-sandbox/lesspass-pure
-sandbox/lesspass-tld/top-1m.csv
-sandbox/infra
+.yarn
+.pnp.*

.yarnrc.yml

@@ -0,0 +1,9 @@
+nodeLinker: node-modules
+
+plugins:
+  - path: .yarn/plugins/@yarnpkg/plugin-workspace-tools.cjs
+    spec: "@yarnpkg/plugin-workspace-tools"
+  - path: .yarn/plugins/@yarnpkg/plugin-interactive-tools.cjs
+    spec: "@yarnpkg/plugin-interactive-tools"
+
+yarnPath: .yarn/releases/yarn-3.5.0.cjs

doc/setup-dev-env.md

@@ -0,0 +1,5 @@
+
+
+    yarn set version berry
+    yarn plugin import workspace-tools
+    yarn plugin import interactive-tools

package.json

@@ -8,22 +8,12 @@
   "workspaces": {
     "packages": [
       "packages/*"
-    ],
-    "nohoist": [
-      "**/lesspass-pure"
     ]
   },
-  "devDependencies": {
-    "@types/jest": "^27.0.3",
-    "browserify": "^17.0.0",
-    "jest": "^27.4.5",
-    "jest-cli": "^27.4.5",
-    "karma": "^6.3.4",
-    "karma-browserify": "^8.1.0",
-    "karma-chrome-launcher": "^3.1.0",
-    "karma-mocha": "^2.0.1",
-    "mocha": "^9.1.2",
-    "ts-jest": "^27.1.2",
-    "typescript": "^4.5.2"
-  }
+  "scripts": {
+    "build": "yarn workspaces foreach -v --topological-dev run build",
+    "clean": "yarn workspaces foreach -v run clean && rm -rf node_modules && rm -rf .yarn",
+    "test": "yarn workspaces foreach -v run test"
+  },
+  "packageManager": "yarn@3.5.0"
 }

packages/.gitignore

@@ -0,0 +1,36 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Dependency directories
+node_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Output of 'npm pack'
+*.tgz
+
+# dotenv environment variables file
+.env
+
+# generate output
+dist
+
+# Cache
+.cache/

packages/lesspass-crypto/.gitignore

@@ -1,2 +0,0 @@
-node_modules
-dist

packages/lesspass-crypto/jest.config.js

@@ -0,0 +1,4 @@
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+};

packages/lesspass-crypto/package.json

@@ -1,29 +1,31 @@
 {
   "name": "lesspass-crypto",
-  "version": "9.2.0",
+  "version": "10.0.0",
   "description": "LessPass cryptographic functions",
   "license": "GPL-3.0",
   "author": "Guillaume Vincent <guillaume@oslab.fr>",
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
-  "main": "./dist/cjs/index.js",
-  "module": "./dist/esm/index.js",
-  "types": "./dist/esm/index.d.ts",
+  "exports": {
+    "development": "./src/index.ts",
+    "types": "./dist/index.d.ts",
+    "default": "./dist/index.js"
+  },
+  "engines": {
+    "node": ">=14"
+  },
   "scripts": {
-    "test": "NODE_OPTIONS=--experimental-vm-modules jest",
-    "clean": "rm -rf dist",
-    "build": "yarn clean && yarn build:cjs && yarn build:esm",
-    "build:cjs": "tsc --module CommonJS --outDir dist/cjs",
-    "build:esm": "tsc --module ESNext --outDir dist/esm --declaration",
-    "prepare": "yarn build"
+    "test": "jest",
+    "build": "yarn clean && tsc",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo"
   },
-  "jest": {
-    "preset": "ts-jest/presets/default-esm",
-    "globals": {
-      "ts-jest": {
-        "useESM": true
-      }
-    }
+  "devDependencies": {
+    "@tsconfig/recommended": "^1.0.2",
+    "@types/jest": "^29.5.0",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.0.5",
+    "typescript": "^4.9.5"
   }
 }

packages/lesspass-crypto/index.ts → packages/lesspass-crypto/src/index.ts

@@ -8,7 +8,7 @@ export function stringToArrayBuffer(s: string) {
   return new Uint8Array(arrayBuffer);
 }
 
-export function arrayBufferToHex(arrayBuffer: Iterable<number>) {
+export function arrayBufferToHex(arrayBuffer: ArrayBuffer) {
   const byteArray = new Uint8Array(arrayBuffer);
   let str = "";
   for (let i = 0; i < byteArray.byteLength; i += 1) {

packages/lesspass-crypto/tsconfig.json

@@ -1,14 +1,11 @@
 {
+  "extends": "../../tsconfig.json",
   "compilerOptions": {
-    "target": "ES6",
-    "lib": ["es6", "es2017.string"],
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "noImplicitAny": true,
-    "noImplicitReturns": true,
-    "skipLibCheck": true
+    "outDir": "dist",
+    "rootDir": "src",
+    "composite": true,
+    "lib": ["ES6", "ES2017.String"]
   },
-  "include": ["index.ts"]
+  "include": ["src"],
+  "exclude": ["src/**/*.test.ts"]
 }

packages/lesspass-entropy/jest.config.js

@@ -0,0 +1,4 @@
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+};

packages/lesspass-entropy/package.json

@@ -1,22 +1,49 @@
 {
   "name": "lesspass-entropy",
-  "version": "9.1.9",
+  "version": "10.0.0",
   "description": "LessPass module used to generate entropy for password generation",
-  "author": "Guillaume Vincent <guillaume@oslab.fr>",
   "license": "GPL-3.0",
+  "author": "Guillaume Vincent <guillaume@oslab.fr>",
   "files": [
+    "dist",
     "src"
   ],
-  "main": "src/index.js",
-  "browser": {
-    "./src/pbkdf2.js": "./src/pbkdf2.browser.js"
+  "exports": {
+    ".": {
+      "development": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./src/pbkdf2.js": {
+      "node": {
+        "development": "./src/pbkdf2.js",
+        "types": "./dist/pbkdf2.d.ts",
+        "default": "./dist/pbkdf2.js"
+      },
+      "browser": {
+        "development": "./src/pbkdf2.browser.ts",
+        "types": "./dist/pbkdf2.browser.d.ts",
+        "default": "./dist/pbkdf2.browser.js"
+      }
+    }
+  },
+  "engines": {
+    "node": ">=14"
   },
   "scripts": {
-    "test": "yarn test:unit && yarn test:browser",
-    "test:unit": "mocha test --recursive",
-    "test:browser": "karma start test/karma.conf.js"
+    "test": "jest",
+    "build": "yarn clean && tsc",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo"
   },
   "dependencies": {
-    "lesspass-crypto": "^9.2.0"
+    "lesspass-crypto": "workspace:*"
+  },
+  "devDependencies": {
+    "@tsconfig/recommended": "^1.0.2",
+    "@types/jest": "^29.5.0",
+    "@types/node": "^18.15.11",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.0.5",
+    "typescript": "^4.9.5"
   }
-}
+}

packages/lesspass-entropy/src/index.js

@@ -1,52 +0,0 @@
-const pbkdf2 = require("./pbkdf2");
-
-function calcEntropy(profile, masterPassword) {
-  const { site, login, options, crypto } = profile;
-  const defaultOptions = { counter: 1 };
-  const { counter } = options || defaultOptions;
-  const salt = site + login + counter.toString(16);
-  const defaultCrypto = { iterations: 100000, keylen: 32, digest: "sha256" };
-  const { iterations, keylen, digest } = crypto || defaultCrypto;
-  return pbkdf2(masterPassword, salt, iterations, keylen, digest);
-}
-
-function isSupported() {
-  try {
-    return calcEntropy(
-      {
-        site: "lesspass.com",
-        login: "♥",
-        options: {
-          uppercase: true,
-          lowercase: true,
-          digits: true,
-          symbols: true,
-          length: 16,
-          counter: 1,
-        },
-        crypto: {
-          method: "pbkdf2",
-          iterations: 1,
-          keylen: 32,
-          digest: "sha256",
-        },
-      },
-      "tHis is a g00d! password"
-    ).then((entropy) => {
-      if (
-        entropy ===
-        "e99e20abab609cc4564ef137acb540de20d9b92dcc5cda58f78ba431444ef2da"
-      ) {
-        return Promise.resolve(true);
-      }
-      return Promise.resolve(false);
-    });
-  } catch (e) {
-    return Promise.resolve(false);
-  }
-}
-
-module.exports = {
-  isSupported,
-  calcEntropy,
-};

packages/lesspass-entropy/test/index.test.js → packages/lesspass-entropy/src/index.test.ts

@@ -1,116 +1,89 @@
-const assert = require("assert");
-const { calcEntropy, isSupported } = require("../src");
+import { calcEntropy, isSupported } from ".";
 
 describe("entropy", () => {
   it("calc entropy without crypto use default options and crypto", () => {
     const profile = {
       site: "example.org",
       login: "contact@example.org",
+      counter: 1,
     };
     const masterPassword = "password";
     return calcEntropy(profile, masterPassword).then((entropy) => {
-      assert.equal(
-        "dc33d431bce2b01182c613382483ccdb0e2f66482cbba5e9d07dab34acc7eb1e",
-        entropy
-      );
+      expect(
+        "dc33d431bce2b01182c613382483ccdb0e2f66482cbba5e9d07dab34acc7eb1e"
+      ).toBe(entropy);
     });
   });
   it("calc entropy pbkdf2 with default params (100000 iterations, 32 bytes length, sha256 digest)", () => {
     const profile = {
       site: "example.org",
       login: "contact@example.org",
-      options: {
-        counter: 1,
-      },
-      crypto: {
-        method: "pbkdf2",
-        iterations: 100000,
-        keylen: 32,
-        digest: "sha256",
-      },
+      counter: 1,
     };
     const masterPassword = "password";
-    return calcEntropy(profile, masterPassword).then((entropy) => {
-      assert.equal(
-        "dc33d431bce2b01182c613382483ccdb0e2f66482cbba5e9d07dab34acc7eb1e",
-        entropy
-      );
+    const crypto = {
+      iterations: 100000,
+      keylen: 32,
+      digest: "sha256",
+    };
+    return calcEntropy(profile, masterPassword, crypto).then((entropy) => {
+      expect(
+        "dc33d431bce2b01182c613382483ccdb0e2f66482cbba5e9d07dab34acc7eb1e"
+      ).toBe(entropy);
     });
   });
   it("calc entropy pbkdf2 with unicode char", () => {
     const profile = {
       site: "example.org",
       login: "❤",
-      options: {
-        counter: 1,
-      },
-      crypto: {
-        method: "pbkdf2",
-        iterations: 100000,
-        keylen: 32,
-        digest: "sha256",
-      },
+      counter: 1,
     };
     const masterPassword = "I ❤ LessPass";
-    return calcEntropy(profile, masterPassword).then((entropy) => {
-      assert.equal(
-        "4e66cab40690c01af55efd595f5963cc953d7e10273c01827881ebf8990c627f",
-        entropy
-      );
+    const crypto = {
+      iterations: 100000,
+      keylen: 32,
+      digest: "sha256",
+    };
+    return calcEntropy(profile, masterPassword, crypto).then((entropy) => {
+      expect(
+        "4e66cab40690c01af55efd595f5963cc953d7e10273c01827881ebf8990c627f"
+      ).toBe(entropy);
     });
   });
   it("calc entropy with different options (8192 iterations, 16 bytes length, sha512 digest)", () => {
     const profile = {
       site: "example.org",
       login: "contact@example.org",
-      options: {
-        counter: 1,
-      },
-      crypto: {
-        method: "pbkdf2",
-        iterations: 8192,
-        keylen: 16,
-        digest: "sha512",
-      },
+      counter: 1,
     };
     const masterPassword = "password";
-    return calcEntropy(profile, masterPassword).then((entropy) => {
-      assert.equal("fff211c16a4e776b3574c6a5c91fd252", entropy);
+    const crypto = {
+      method: "pbkdf2",
+      iterations: 8192,
+      keylen: 16,
+      digest: "sha512",
+    };
+    return calcEntropy(profile, masterPassword, crypto).then((entropy) => {
+      expect("fff211c16a4e776b3574c6a5c91fd252").toBe(entropy);
     });
   });
-  it("calc entropy different if counter different 1", () => {
+  it("calc entropy are different if counter are different", () => {
     const profile = {
       site: "example.org",
       login: "contact@example.org",
-      options: {
-        counter: 1,
-      },
-      crypto: {
-        method: "pbkdf2",
-        iterations: 100000,
-        keylen: 32,
-        digest: "sha256",
-      },
+      counter: 1,
     };
     const profile2 = {
       site: "example.org",
       login: "contact@example.org",
-      options: {
-        counter: 2,
-      },
-      crypto: {
-        method: "pbkdf2",
-        iterations: 100000,
-        keylen: 32,
-        digest: "sha256",
-      },
+      counter: 2,
     };
     const promises = [
       calcEntropy(profile, "password"),
       calcEntropy(profile2, "password"),
     ];
     Promise.all(promises).then((values) => {
-      assert.notEqual(values[0], values[1]);
+      expect(values[0]).not.toEqual(values[1]);
     });
   });
 });
@@ -118,6 +91,6 @@ describe("entropy", () => {
 describe("isSupported", () => {
   it("isSupported", () =>
     isSupported().then((supported) => {
-      assert(supported);
+      expect(supported).toBe(true);
     }));
 });

packages/lesspass-entropy/src/index.ts

@@ -0,0 +1,60 @@
+import pbkdf2 from "./pbkdf2";
+
+export interface SiteLoginCounter {
+  site: string;
+  login: string;
+  counter: number;
+}
+interface Crypto {
+  iterations?: number;
+  keylen?: number;
+  digest?: string;
+}
+export function calcEntropy(
+  siteLoginAndCounter: SiteLoginCounter & { [k: string]: unknown },
+  masterPassword: string,
+  crypto: Crypto = {}
+) {
+  const { site, login, counter } = siteLoginAndCounter;
+  const salt = site + login + counter.toString(16);
+  const { iterations, keylen, digest } = {
+    iterations: 100000,
+    keylen: 32,
+    digest: "sha256",
+    ...crypto,
+  };
+  return pbkdf2(masterPassword, salt, iterations, keylen, digest);
+}
+
+export function isSupported(): Promise<boolean> {
+  return calcEntropy(
+    {
+      site: "lesspass.com",
+      login: "♥",
+      uppercase: true,
+      lowercase: true,
+      digits: true,
+      symbols: true,
+      length: 16,
+      counter: 1,
+    },
+    "tHis is a g00d! password",
+    {
+      iterations: 1,
+      keylen: 32,
+      digest: "sha256",
+    }
+  )
+    .then((entropy) =>
+      Promise.resolve(
+        entropy ===
+          "e99e20abab609cc4564ef137acb540de20d9b92dcc5cda58f78ba431444ef2da"
+      )
+    )
+    .catch((e) => Promise.resolve(false));
+}
+
+export default {
+  isSupported,
+  calcEntropy,
+};

packages/lesspass-entropy/src/pbkdf2.browser.js → packages/lesspass-entropy/src/pbkdf2.browser.ts

@@ -1,10 +1,16 @@
-const {
+import {
   stringToArrayBuffer,
   arrayBufferToHex,
   getAlgorithm,
-} = require("lesspass-crypto");
+} from "lesspass-crypto";
 
-module.exports = function pbkdf2(password, salt, iterations, keylen, digest) {
+export default function pbkdf2(
+  password: string,
+  salt: string,
+  iterations: number,
+  keylen: number,
+  digest: string
+) {
   return window.crypto.subtle
     .importKey("raw", stringToArrayBuffer(password), "PBKDF2", false, [
       "deriveKey",
@@ -32,4 +38,4 @@ module.exports = function pbkdf2(password, salt, iterations, keylen, digest) {
         .exportKey("raw", derivedKey)
         .then((keyArray) => arrayBufferToHex(keyArray))
     );
-};
+}

packages/lesspass-entropy/test/pbkdf2.test.js → packages/lesspass-entropy/src/pbkdf2.test.ts

@@ -1,140 +1,124 @@
-const assert = require("assert");
-const pbkdf2 = require("../src/pbkdf2");
+import pbkdf2 from "./pbkdf2";
 
 describe("pbkdf2", () => {
   it("secret, salt, 2 iterations, 32 keylen, sha256 hash", () =>
     pbkdf2("secret", "salt", 2, 32, "sha256").then((key) => {
-      assert.equal(
-        "f92f45f9df4c2aeabae1ed3c16f7b64660c1f8e377fa9b4699b23c2c3a29f569",
-        key
-      );
+      expect(
+        "f92f45f9df4c2aeabae1ed3c16f7b64660c1f8e377fa9b4699b23c2c3a29f569"
+      ).toBe(key);
     }));
   it("use pbkdf2 with 8192 iterations and sha256", () =>
     pbkdf2("password", "test@example.org", 8192, 32, "sha256").then((key) => {
-      assert.equal(
-        "d8af5f918db6b65b1db3d3984e5a400e39e1dbb19462220e4431de283809f472",
-        key
-      );
+      expect(
+        "d8af5f918db6b65b1db3d3984e5a400e39e1dbb19462220e4431de283809f472"
+      ).toBe(key);
     }));
   it("customize number of iterations", () =>
     pbkdf2("password", "test@example.org", 4096, 32, "sha256").then((key) => {
-      assert.equal(
-        "0a91208545e3aa4935d3a22984ca097a7669259a04d261ac16361bdc1a2e960f",
-        key
-      );
+      expect(
+        "0a91208545e3aa4935d3a22984ca097a7669259a04d261ac16361bdc1a2e960f"
+      ).toBe(key);
     }));
   it("customize key length", () =>
     pbkdf2("password", "test@example.org", 8192, 16, "sha256").then((key) => {
-      assert.equal("d8af5f918db6b65b1db3d3984e5a400e", key);
+      expect("d8af5f918db6b65b1db3d3984e5a400e").toBe(key);
     }));
   it("customize iterations and key length", () =>
     pbkdf2("password", "test@example.org", 4096, 16, "sha256").then((key) => {
-      assert.equal("0a91208545e3aa4935d3a22984ca097a", key);
+      expect("0a91208545e3aa4935d3a22984ca097a").toBe(key);
     }));
   it("utf8 parameter", () =>
     pbkdf2("♥ LessPass ♥", "test@example.org", 8192, 32, "sha256").then(
       (key) => {
-        assert.equal(
-          "997fe81d3d0db236e039c75efdb487f17a902fdf94f9dacaa9884329c85d9651",
-          key
-        );
+        expect(
+          "997fe81d3d0db236e039c75efdb487f17a902fdf94f9dacaa9884329c85d9651"
+        ).toBe(key);
       }
     ));
   it("auto generated test 0", () =>
     pbkdf2("password", "contact@lesspass.com", 8192, 32, "sha256").then(
       (key) => {
-        assert.equal(
-          "63d850713d0b2f7f2c4396fe93f4ac0c6bc7485f9e7473c4b8c4a33ec12199c0",
-          key
-        );
+        expect(
+          "63d850713d0b2f7f2c4396fe93f4ac0c6bc7485f9e7473c4b8c4a33ec12199c0"
+        ).toBe(key);
       }
     ));
   it("auto generated test 1", () =>
     pbkdf2("password", "contact@lesspass.com", 8192, 32, "sha256").then(
       (key) => {
-        assert.equal(
-          "63d850713d0b2f7f2c4396fe93f4ac0c6bc7485f9e7473c4b8c4a33ec12199c0",
-          key
-        );
+        expect(
+          "63d850713d0b2f7f2c4396fe93f4ac0c6bc7485f9e7473c4b8c4a33ec12199c0"
+        ).toBe(key);
       }
     ));
   it("auto generated test 2", () =>
     pbkdf2("password", "contact@lesspass.com", 8192, 32, "sha256").then(
       (key) => {
-        assert.equal(
-          "63d850713d0b2f7f2c4396fe93f4ac0c6bc7485f9e7473c4b8c4a33ec12199c0",
-          key
-        );
+        expect(
+          "63d850713d0b2f7f2c4396fe93f4ac0c6bc7485f9e7473c4b8c4a33ec12199c0"
+        ).toBe(key);
       }
     ));
   it("auto generated test 3", () =>
     pbkdf2("password", "contact@lesspass.com", 8192, 32, "sha256").then(
       (key) => {
-        assert.equal(
-          "63d850713d0b2f7f2c4396fe93f4ac0c6bc7485f9e7473c4b8c4a33ec12199c0",
-          key
-        );
+        expect(
+          "63d850713d0b2f7f2c4396fe93f4ac0c6bc7485f9e7473c4b8c4a33ec12199c0"
+        ).toBe(key);
       }
     ));
   it("auto generated test 4", () =>
     pbkdf2("password", "contact@lesspass.com", 8192, 32, "sha256").then(
       (key) => {
-        assert.equal(
-          "63d850713d0b2f7f2c4396fe93f4ac0c6bc7485f9e7473c4b8c4a33ec12199c0",
-          key
-        );
+        expect(
+          "63d850713d0b2f7f2c4396fe93f4ac0c6bc7485f9e7473c4b8c4a33ec12199c0"
+        ).toBe(key);
       }
     ));
   it("auto generated test 5", () =>
     pbkdf2("password", "contact@lesspass.com", 8192, 32, "sha256").then(
       (key) => {
-        assert.equal(
-          "63d850713d0b2f7f2c4396fe93f4ac0c6bc7485f9e7473c4b8c4a33ec12199c0",
-          key
-        );
+        expect(
+          "63d850713d0b2f7f2c4396fe93f4ac0c6bc7485f9e7473c4b8c4a33ec12199c0"
+        ).toBe(key);
       }
     ));
   it("auto generated test 6", () =>
     pbkdf2("password", "contact@lesspass.com", 8192, 32, "sha256").then(
       (key) => {
-        assert.equal(
-          "63d850713d0b2f7f2c4396fe93f4ac0c6bc7485f9e7473c4b8c4a33ec12199c0",
-          key
-        );
+        expect(
+          "63d850713d0b2f7f2c4396fe93f4ac0c6bc7485f9e7473c4b8c4a33ec12199c0"
+        ).toBe(key);
       }
     ));
   it("auto generated test 7", () =>
     pbkdf2("password", "contact@lesspass.com", 8192, 32, "sha256").then(
       (key) => {
-        assert.equal(
-          "63d850713d0b2f7f2c4396fe93f4ac0c6bc7485f9e7473c4b8c4a33ec12199c0",
-          key
-        );
+        expect(
+          "63d850713d0b2f7f2c4396fe93f4ac0c6bc7485f9e7473c4b8c4a33ec12199c0"
+        ).toBe(key);
       }
     ));
   it("auto generated test 8", () =>
     pbkdf2("password", "contact@lesspass.com", 8192, 32, "sha256").then(
       (key) => {
-        assert.equal(
-          "63d850713d0b2f7f2c4396fe93f4ac0c6bc7485f9e7473c4b8c4a33ec12199c0",
-          key
-        );
+        expect(
+          "63d850713d0b2f7f2c4396fe93f4ac0c6bc7485f9e7473c4b8c4a33ec12199c0"
+        ).toBe(key);
       }
     ));
   it("auto generated test 9", () =>
     pbkdf2("password", "lesspass", 8192, 32, "sha256").then((key) => {
-      assert.equal(
-        "7d05ee25597dcc3ac16d082aa910e7707f75be620ed8db5bef7245e2a8579116",
-        key
-      );
+      expect(
+        "7d05ee25597dcc3ac16d082aa910e7707f75be620ed8db5bef7245e2a8579116"
+      ).toBe(key);
     }));
   it("auto generated test 10", () =>
     pbkdf2("password2", "contact@lesspass.com", 8192, 32, "sha256").then(
       (key) => {
-        assert.equal(
-          "ce853092fc54fe88c281e38df97bd5826d64e6bee315dc94939cbba8930df0e4",
-          key
-        );
+        expect(
+          "ce853092fc54fe88c281e38df97bd5826d64e6bee315dc94939cbba8930df0e4"
+        ).toBe(key);
       }
     ));
 });

packages/lesspass-entropy/src/pbkdf2.js → packages/lesspass-entropy/src/pbkdf2.ts

@@ -1,6 +1,12 @@
-const crypto = require("crypto");
+import crypto from "crypto";
 
-module.exports = function pbkdf2(password, salt, iterations, keylen, digest) {
+export default function pbkdf2(
+  password: string,
+  salt: string,
+  iterations: number,
+  keylen: number,
+  digest: string
+):Promise<string> {
   return new Promise((resolve, reject) => {
     crypto.pbkdf2(password, salt, iterations, keylen, digest, (error, key) => {
       if (error) {
@@ -10,4 +16,4 @@ module.exports = function pbkdf2(password, salt, iterations, keylen, digest) {
       }
     });
   });
-};
+}

packages/lesspass-entropy/src/stringEncoding.test.ts

@@ -0,0 +1,11 @@
+import { stringToArrayBuffer, arrayBufferToHex } from "./stringEncoding";
+
+describe("stringEncoding", () => {
+  it("stringToArrayBuffer", () => {
+    expect(stringToArrayBuffer("ȧ")[0]).toBe(200);
+    expect(stringToArrayBuffer("ȧ")[1]).toBe(167);
+  });
+  it("arrayBufferToHex", () => {
+    expect(arrayBufferToHex(new Uint8Array([200, 167]))).toBe("c8a7");
+  });
+});

packages/lesspass-entropy/src/stringEncoding.js → packages/lesspass-entropy/src/stringEncoding.ts

@@ -1,14 +1,14 @@
-function stringToArrayBuffer(string) {
+export function stringToArrayBuffer(string: string) {
   const base64String = unescape(encodeURIComponent(string));
   const charList = base64String.split("");
-  const arrayBuffer = [];
+  const arrayBuffer: number[] = [];
   for (let i = 0; i < charList.length; i += 1) {
     arrayBuffer.push(charList[i].charCodeAt(0));
   }
   return new Uint8Array(arrayBuffer);
 }
 
-function arrayBufferToHex(arrayBuffer) {
+export function arrayBufferToHex(arrayBuffer: Iterable<number>) {
   const byteArray = new Uint8Array(arrayBuffer);
   let str = "";
   for (let i = 0; i < byteArray.byteLength; i += 1) {
@@ -17,7 +17,7 @@ function arrayBufferToHex(arrayBuffer) {
   return str;
 }
 
-module.exports = {
+export default {
   stringToArrayBuffer,
   arrayBufferToHex,
 };

packages/lesspass-entropy/test/karma.conf.js

@@ -1,14 +0,0 @@
-module.exports = (config) => {
-  config.set({
-    basePath: "..",
-    frameworks: ["mocha", "browserify"],
-    plugins: ["karma-mocha", "karma-browserify", "karma-chrome-launcher"],
-    files: ["src/index.js", "test/**/*.js"],
-    preprocessors: {
-      "src/index.js": ["browserify"],
-      "test/**/*.js": ["browserify"],
-    },
-    browsers: ["ChromeHeadless"],
-    singleRun: true,
-  });
-};

packages/lesspass-entropy/test/stringEncoding.test.js

@@ -1,15 +0,0 @@
-const assert = require("assert");
-const {
-  stringToArrayBuffer,
-  arrayBufferToHex,
-} = require("../src/stringEncoding");
-
-describe("stringEncoding", () => {
-  it("stringToArrayBuffer", () => {
-    assert.equal(stringToArrayBuffer("ȧ")[0], 200);
-    assert.equal(stringToArrayBuffer("ȧ")[1], 167);
-  });
-  it("arrayBufferToHex", () => {
-    assert.equal(arrayBufferToHex(new Uint8Array([200, 167])), "c8a7");
-  });
-});

packages/lesspass-entropy/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "composite": true,
+    "lib": ["ES6", "ES2017.String", "DOM"],
+    "paths": {
+      "lesspass-crypto": ["../lesspass-crypto/src/index.ts"]
+    }
+  },
+  "include": ["src"],
+  "exclude": ["src/**/*.test.ts"],
+  "references": [{ "path": "../lesspass-crypto" }]
+}

packages/lesspass-fingerprint/jest.config.js

@@ -0,0 +1,4 @@
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+};

packages/lesspass-fingerprint/package.json

@@ -1,22 +1,49 @@
 {
   "name": "lesspass-fingerprint",
-  "version": "9.1.9",
+  "version": "10.0.0",
   "description": "LessPass node module used to get fingerprint for 256 bytes string",
-  "license": "GPL-3.0",
   "author": "Guillaume Vincent <guillaume@oslab.fr>",
+  "license": "GPL-3.0",
   "files": [
+    "dist",
     "src"
   ],
-  "main": "src/index.js",
-  "browser": {
-    "./src/hmac.js": "./src/hmac.browser.js"
+  "exports": {
+    ".": {
+      "development": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./src/hmac.ts": {
+      "node": {
+        "development": "./src/hmac.ts",
+        "types": "./dist/hmac.d.ts",
+        "default": "./dist/hmac.js"
+      },
+      "browser": {
+        "development": "./src/hmac.browser.ts",
+        "types": "./dist/hmac.browser.d.ts",
+        "default": "./dist/hmac.browser.js"
+      }
+    }
+  },
+  "engines": {
+    "node": ">=14"
   },
   "scripts": {
-    "test": "yarn test:unit && yarn test:browser",
-    "test:unit": "mocha test --recursive",
-    "test:browser": "karma start test/karma.conf.js"
+    "test": "jest",
+    "build": "yarn clean && tsc",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo"
   },
   "dependencies": {
-    "lesspass-crypto": "^9.2.0"
+    "lesspass-crypto": "workspace:*"
+  },
+  "devDependencies": {
+    "@tsconfig/recommended": "^1.0.2",
+    "@types/jest": "^29.5.0",
+    "@types/node": "^18.15.11",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.0.5",
+    "typescript": "^4.9.5"
   }
 }

packages/lesspass-fingerprint/src/fingerprint.js → packages/lesspass-fingerprint/src/fingerprint.ts

@@ -1,4 +1,4 @@
-function getColor(color) {
+export function getColor(color: string) {
   const colors = [
     "#000000",
     "#074750",
@@ -19,7 +19,7 @@ function getColor(color) {
   return colors[index];
 }
 
-function getIcon(hash) {
+export function getIcon(hash: string) {
   const icons = [
     "fa-hashtag",
     "fa-heart",
@@ -72,7 +72,7 @@ function getIcon(hash) {
   return icons[index];
 }
 
-module.exports = function (hmacSHA256) {
+export default function generateFingerprint(hmacSHA256: string) {
   const fingerprint = [];
   const hash1 = hmacSHA256.substring(0, 6);
   fingerprint.push({
@@ -93,4 +93,4 @@ module.exports = function (hmacSHA256) {
   });
 
   return fingerprint;
-};
+}

packages/lesspass-fingerprint/src/hmac.browser.js → packages/lesspass-fingerprint/src/hmac.browser.ts

@@ -1,24 +1,24 @@
-const {
+import {
   stringToArrayBuffer,
   arrayBufferToHex,
   getAlgorithm,
-} = require("lesspass-crypto");
+} from "lesspass-crypto";
 
-module.exports = function hmac(digest, string, salt) {
+export default function hmac(algorithm: string, key: string, data?: string) {
   return window.crypto.subtle
     .importKey(
       "raw",
-      stringToArrayBuffer(string),
+      stringToArrayBuffer(key),
       {
         name: "HMAC",
-        hash: { name: getAlgorithm(digest) },
+        hash: { name: getAlgorithm(algorithm) },
       },
       true,
       ["sign", "verify"]
     )
     .then((key) =>
       window.crypto.subtle
-        .sign({ name: "HMAC" }, key, stringToArrayBuffer(salt || ""))
+        .sign({ name: "HMAC" }, key, stringToArrayBuffer(data || ""))
         .then((signature) => arrayBufferToHex(signature))
     );
-};
+}

packages/lesspass-fingerprint/src/hmac.js

@@ -1,12 +0,0 @@
-const crypto = require("crypto");
-
-module.exports = function (digest, string, salt) {
-  return new Promise((resolve) => {
-    resolve(
-      crypto
-        .createHmac(digest, string)
-        .update(salt || "")
-        .digest("hex")
-    );
-  });
-};

packages/lesspass-fingerprint/src/hmac.ts

@@ -0,0 +1,16 @@
+import crypto, { BinaryLike } from "crypto";
+
+export default function hmac(
+  algorithm: string,
+  key: BinaryLike,
+  data?: BinaryLike
+): Promise<string> {
+  return new Promise((resolve) => {
+    resolve(
+      crypto
+        .createHmac(algorithm, key)
+        .update(data || "")
+        .digest("hex")
+    );
+  });
+}

packages/lesspass-fingerprint/src/index.js

@@ -1,7 +0,0 @@
-const createFingerprint = require("./fingerprint");
-const createHmac = require("./hmac");
-
-module.exports = {
-  createFingerprint,
-  createHmac,
-};

packages/lesspass-fingerprint/test/api.test.js → packages/lesspass-fingerprint/src/index.test.ts

@@ -1,28 +1,24 @@
-const assert = require("assert");
-const { createFingerprint, createHmac } = require("../src");
+import { createFingerprint, createHmac } from ".";
 
 describe("api", () => {
   it("createHmac", () =>
     createHmac("sha256", "password").then((fingerprint) => {
-      assert.equal(
-        "e56a207acd1e6714735487c199c6f095844b7cc8e5971d86c003a7b6f36ef51e",
-        fingerprint
-      );
+      expect(
+        "e56a207acd1e6714735487c199c6f095844b7cc8e5971d86c003a7b6f36ef51e"
+      ).toBe(fingerprint);
     }));
   it("createHmac and update", () =>
     createHmac("sha256", "password", "salt").then((fingerprint) => {
-      assert.equal(
-        "fc328232993ff34ca56631e4a101d60393cad12171997ee0b562bf7852b2fed0",
-        fingerprint
-      );
+      expect(
+        "fc328232993ff34ca56631e4a101d60393cad12171997ee0b562bf7852b2fed0"
+      ).toBe(fingerprint);
     }));
   it("fingerprint is length of 3", () => {
-    assert.equal(
+    expect(
       createFingerprint(
         "e56a207acd1e6714735487c199c6f095844b7cc8e5971d86c003a7b6f36ef51e"
-      ).length,
-      3
-    );
+      ).length
+    ).toBe(3);
   });
   it("fingerprint is length of 3", () => {
     const expectedFingerprint = [
@@ -39,11 +35,10 @@ describe("api", () => {
         icon: "fa-beer",
       },
     ];
-    assert.deepEqual(
+    expect(
       createFingerprint(
         "e56a207acd1e6714735487c199c6f095844b7cc8e5971d86c003a7b6f36ef51e"
-      ),
-      expectedFingerprint
-    );
+      )
+    ).toEqual(expectedFingerprint);
   });
 });

packages/lesspass-fingerprint/src/index.ts

@@ -0,0 +1,9 @@
+import createFingerprint from "./fingerprint";
+import createHmac from "./hmac";
+
+export { createFingerprint, createHmac };
+
+export default {
+  createFingerprint,
+  createHmac,
+};

packages/lesspass-fingerprint/test/karma.conf.js

@@ -1,14 +0,0 @@
-module.exports = (config) => {
-  config.set({
-    basePath: "..",
-    frameworks: ["mocha", "browserify"],
-    plugins: ["karma-mocha", "karma-browserify", "karma-chrome-launcher"],
-    files: ["src/index.js", "test/**/*.js"],
-    preprocessors: {
-      "src/index.js": ["browserify"],
-      "test/**/*.js": ["browserify"],
-    },
-    browsers: ["ChromeHeadless"],
-    singleRun: true,
-  });
-};

packages/lesspass-fingerprint/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "composite": true,
+    "paths": {
+      "lesspass-crypto": ["../lesspass-crypto/src/index.ts"]
+    }
+  },
+  "include": ["src"],
+  "exclude": ["src/**/*.test.ts"],
+  "references": [{ "path": "../lesspass-crypto" }]
+}