chore: polishing

Author: TheAlexLichter

src/base64.js

@@ -1,4 +1,4 @@
-import { isBrowser } from './helpers/index'
+import { isBrowser } from './helpers'
 
 // Courtesy: https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#The_Unicode_Problem
 

src/dtmf.js

@@ -1,4 +1,4 @@
-import { throwOrSilent } from './helpers/index'
+import { mergeObjects, throwOrSilent, toNumber } from './helpers'
 
 const decode = (input, options = {}) => {
   options = { ...DEFAULT_OPTIONS, ...options }
@@ -32,9 +32,19 @@ const decode = (input, options = {}) => {
 
 const includesKey = i => ([key]) => i.includes(key)
 
-const getLookup = mode => mode === 'include' ? LOOKUP : Object.entries(LOOKUP).map(([k, rowObj]) => {
-  return Object.entries(rowObj).reduce((acc, [rowK, v]) => ({ ...acc, ...{ [mode === 'sum' ? Number(rowK) + Number(k) : Number(rowK) - Number(k)]: v } }), {})
-}).reduce((acc, obj) => ({ ...acc, ...obj }), {})
+const getLookup = mode => mode === 'include' ? LOOKUP : getSumOrDiffLookup(mode)
+
+const getSumOrDiffLookup = mode => Object.entries(LOOKUP)
+  .map(([colFrequency, rowObject]) =>
+    Object.entries(rowObject).reduce((acc, cellObject) => mergeObjects(acc, getLookupObject(mode, colFrequency, cellObject)), {}))
+  .reduce(mergeObjects, {})
+
+const getLookupObject = (mode, colFrequency, [rowFrequency, character]) => {
+  [rowFrequency, colFrequency] = toNumber(rowFrequency, colFrequency)
+
+  const lookupKey = mode === 'sum' ? rowFrequency + colFrequency : rowFrequency - colFrequency
+  return { [lookupKey]: character }
+}
 
 const encode = (input, options = {}) => {
   options = { ...DEFAULT_OPTIONS, ...options }
@@ -44,10 +54,8 @@ const encode = (input, options = {}) => {
   return [...input].map(i => {
     const result = Object.entries(LOOKUP).map(([key, freqOb]) => {
       const foundFreq = Object.entries(freqOb).find(([k, v]) => v === i)
-      if (foundFreq) {
-        return encodeResult([key, foundFreq[0]], options)
-      }
-      return false
+
+      return foundFreq ? encodeResult([key, foundFreq[0]], options) : false
     }).find(o => o)
 
     return !result ? throwOrSilent(options, 'Invalid input') : result
@@ -60,7 +68,7 @@ const encodeResult = (frequencies, { mode, invertedOutput, connector }) => {
     frequencies.reverse()
   }
 
-  frequencies = frequencies.map(f => Number(f))
+  frequencies = toNumber(...frequencies)
 
   const resultObjects = {
     include: `${frequencies[0]}${connector}${frequencies[1]}`,

src/fractionatedMorse.js

@@ -1,5 +1,5 @@
 import morse from './morse'
-import { throwOrSilent } from './helpers/index'
+import { throwOrSilent } from './helpers'
 
 export const decode = (input, options = {}) => {
   options = { ...DEFAULT_OPTIONS, ...options }

src/helpers/index.js

@@ -43,3 +43,7 @@ export const modInverse = (number, mod) => {
   // Now find the mod inverse number or return false. Mod inverse: (i * number = 1) % mod
   return (rangeArray.find(i => i * number % mod === 1) % mod) || false
 }
+
+export const toNumber = (...args) => args.map(a => Number(a))
+
+export const mergeObjects = (a, b) => ({ ...a, ...b })

src/manchester.js

@@ -1,4 +1,4 @@
-import { throwOrSilent } from './helpers/index'
+import { throwOrSilent } from './helpers'
 
 const decode = (input, options = {}) => {
   options = { ...DEFAULT_OPTIONS, ...options }

src/morse.js

@@ -1,31 +1,33 @@
-import { throwOrSilent } from './helpers/index'
+import { throwOrSilent } from './helpers'
 
 export const decode = (input, options = {}) => {
   options = { ...DEFAULT_OPTIONS, ...options }
-  return input.split(options.separator).map(c => {
-    const decodedCharacter = Object.entries(ALPHABET).find(([k, v]) => v === c)
+
+  return input.split(options.separator).map(character => {
+    const decodedCharacter = Object.entries(ALPHABET).find(([_, morse]) => morse === character)
 
     if (decodedCharacter) {
       return decodedCharacter[0]
     }
-    throwOrSilent(options, `Undecodable character ${c}`)
+    throwOrSilent(options, `Undecodable character ${character}`)
 
-    return options.omitUnknownCharacter ? '' : c
+    return options.omitUnknownCharacter ? '' : character
   }).join('')
 }
 
 export const encode = (input, options = {}) => {
   options = { ...DEFAULT_OPTIONS, ...options }
 
-  return [...input.toUpperCase()].map(c => {
-    const encodedCharacter = Object.entries(ALPHABET).find(([k]) => k === c)
+  return [...input.toUpperCase()].map(character => {
+    const encodedCharacter = Object.entries(ALPHABET).find(([clearCharacter]) => clearCharacter === character)
 
     if (encodedCharacter) {
       return encodedCharacter[1]
     }
-    throwOrSilent(options, `Unencodable character ${c}`)
 
-    return options.omitUnknownCharacter ? '' : c
+    throwOrSilent(options, `Unencodable character ${character}`)
+
+    return options.omitUnknownCharacter ? '' : character
   }).join(options.separator)
 }
 

src/multiTap.js

@@ -1,4 +1,4 @@
-import { throwOrSilent } from './helpers/index'
+import { mergeObjects, throwOrSilent } from './helpers'
 
 export const encode = (input, options = {}) => {
   options = { ...DEFAULT_OPTIONS, ...options }
@@ -17,31 +17,44 @@ export const encode = (input, options = {}) => {
 
 export const decode = (input, options = {}) => {
   options = { ...DEFAULT_OPTIONS, ...options }
-  const alphabet = alphabetWithSpaceKey(options.customMapping)
 
+  const alphabet = alphabetWithSpaceKey(options.customMapping)
   const invalidInputRegex = /[^\d^*# ]/g
+  const exponentFormRegex = /\d\^\d ?/g
+  const normalFormRegex = /(([79])\2{0,4}|([234568])\3{0,2}|([01*#])\4{0,2}) ?/g
 
   // Validate input
   if (input.match(invalidInputRegex)) {
     if (options.failOnUnknownCharacter) {
       throw Error(`Undecodable characters`)
-    } else {
-      input.replace(invalidInputRegex)
     }
+
+    input.replace(invalidInputRegex)
   }
 
   if (!input.length) {
     return ''
   }
 
-  const capturedInput = options.exponentForm ? input.match(/\d\^\d ?/g) : input.match(/(([79])\2{0,4}|([234568])\3{0,2}|([01*#])\4{0,2}) ?/g)
+  const capturedInput = options.exponentForm ? input.match(exponentFormRegex) : input.match(normalFormRegex)
+
   return capturedInput.map(expr => {
     expr = expr.replace(/ /g, '')
-    return options.exponentForm ? alphabet[expr[0]][expr[2] - 1] : alphabet[expr[0]][expr.length - 1]
+    /*
+     * Retrieve the letter from the lookup object.
+     * In exponent form use the number as key and get the letter on the exponent index
+     * In "normal form" use the number as key as well, but determine the latter based on the length of the expression
+     * Subtract one because array indices start at 0
+     */
+    const cellIdentifier = (options.exponentForm ? expr[2] : expr.length) - 1
+    return alphabet[expr[0]][cellIdentifier]
   }).join('')
 }
 
-const alphabetWithSpaceKey = customMapping => typeof customMapping === 'object' ? { ...ALPHABET, ...customMapping } : ALPHABET
+const alphabetWithSpaceKey = customMapping =>
+  customMapping && typeof customMapping === 'object'
+    ? mergeObjects(ALPHABET, customMapping)
+    : ALPHABET
 
 const DEFAULT_OPTIONS = {
   customMapping: {

src/pollux.js

@@ -1,6 +1,6 @@
 /* eslint-disable no-unused-vars */
 import morse from './morse'
-import { randomInRange } from './helpers/index'
+import { randomInRange } from './helpers'
 
 export const decode = (input, keys = {}, morseOptions = {}) => {
   sanitizeKeys(keys)

src/polybius.js

@@ -66,9 +66,8 @@ const DEFAULT_OPTIONS = {
 }
 
 const prepareGridString = options =>
-  [...options.key.toUpperCase(), ...getAlphabet(options)].reduce((acc, letter) => {
-    return !acc.includes(letter) ? acc.concat(letter) : acc
-  })
+  [...options.key.toUpperCase(), ...getAlphabet(options)]
+    .reduce((acc, letter) => !acc.includes(letter) ? acc.concat(letter) : acc)
 
 const getAlphabet = options => {
   const [substitute, toReplace] = [...options.equalLetters]