Rework entropy bits offset tracking

Author: dingosky

src/lib/bits.ts

@@ -59,27 +59,6 @@ const bitShifts = (chars: string): BitShifts => {
     )
 }
 
-const valueAt = (lOffset: number, nBits: number, puidBytes: PuidBytes): number => {
-  const lByteNdx = floor(lOffset / 8)
-  const lByte = puidBytes[lByteNdx]
-
-  const lBitNum = lOffset % 8
-  // eslint-disable-next-line functional/no-let
-  let rBitNum = lBitNum + nBits
-
-  if (rBitNum <= 8) {
-    return ((lByte << lBitNum) & 0xff) >> (lBitNum + (8 - rBitNum))
-  }
-  rBitNum -= 8
-
-  const rByte = puidBytes[lByteNdx + 1]
-
-  const lValue = ((lByte << lBitNum) & 0xff) >> (lBitNum - rBitNum)
-  const rValue = rByte >> (8 - rBitNum)
-
-  return lValue + rValue
-}
-
 const entropyByBytes = (skipBytes: number, entropyBuffer: EntropyBuffer, sourceBytes: EntropyByBytes) => {
   const entropyBytes = new Uint8Array(entropyBuffer)
   const bytesLen = entropyBytes.length
@@ -100,21 +79,15 @@ const entropyByValues = (skipBytes: number, entropyBuffer: EntropyBuffer, source
   }
 }
 
-const fillEntropy = (entropyBits: EntropyBits, entropyFunction: EntropyFunction) => {
-  const [offset, entropyBuffer] = entropyBits
-
+const fillEntropy = (entropyOffset: number, entropyBuffer: ArrayBuffer, entropyFunction: EntropyFunction): number => {
   const entropyBytes: PuidBytes = new Uint8Array(entropyBuffer)
 
   const nEntropyBytes = entropyBytes.length
   const nEntropyBits = 8 * nEntropyBytes
 
-  // New offset
-  // eslint-disable-next-line functional/immutable-data
-  entropyBits[0] = offset % 8
-
   const [byValues, entropySource] = entropyFunction
 
-  if (offset === nEntropyBits) {
+  if (entropyOffset === nEntropyBits) {
     // No carry
     if (byValues) {
       entropyByValues(0, entropyBuffer, entropySource as EntropyByValues)
@@ -123,10 +96,10 @@ const fillEntropy = (entropyBits: EntropyBits, entropyFunction: EntropyFunction)
     }
   } else {
     // Handle carry
-    const nUnusedBits = nEntropyBits - offset
+    const nUnusedBits = nEntropyBits - entropyOffset
     const nUnusedBytes = ceil(nUnusedBits / 8)
 
-    const offsetByteNum = floor(offset / 8)
+    const offsetByteNum = floor(entropyOffset / 8)
 
     // Move unused bytes to the left
     const unusedBytes = new Uint8Array(entropyBuffer, offsetByteNum)
@@ -139,6 +112,29 @@ const fillEntropy = (entropyBits: EntropyBits, entropyFunction: EntropyFunction)
       entropyByBytes(nUnusedBytes, entropyBuffer, entropySource as EntropyByBytes)
     }
   }
+
+  return entropyOffset % 8
+}
+
+const valueAt = (lOffset: number, nBits: number, puidBytes: PuidBytes): number => {
+  const lByteNdx = floor(lOffset / 8)
+  const lByte = puidBytes[lByteNdx]
+
+  const lBitNum = lOffset % 8
+  // eslint-disable-next-line functional/no-let
+  let rBitNum = lBitNum + nBits
+
+  if (rBitNum <= 8) {
+    return ((lByte << lBitNum) & 0xff) >> (lBitNum + (8 - rBitNum))
+  }
+  rBitNum -= 8
+
+  const rByte = puidBytes[lByteNdx + 1]
+
+  const lValue = ((lByte << lBitNum) & 0xff) >> (lBitNum - rBitNum)
+  const rValue = rByte >> (8 - rBitNum)
+
+  return lValue + rValue
 }
 
 export default (puidLen: number, puidChars: string, entropyFunction: EntropyFunction): PuidBitsMuncherResult => {
@@ -147,8 +143,9 @@ export default (puidLen: number, puidChars: string, entropyFunction: EntropyFunc
   const nBytesPerPuid = ceil(nBitsPerPuid / 8)
 
   const bufferLen = nBytesPerPuid + 1
+  // eslint-disable-next-line functional/no-let
+  let entropyOffset = 8 * bufferLen
   const entropyBuffer = new ArrayBuffer(bufferLen)
-  const entropyBits: EntropyBits = [8 * bufferLen, entropyBuffer]
   const entropyBytes = new Uint8Array(entropyBuffer)
 
   const charsEncoder = encoder(puidChars)
@@ -158,13 +155,11 @@ export default (puidLen: number, puidChars: string, entropyFunction: EntropyFunc
   if (isPow2(nChars)) {
     // When chars count is a power of 2, sliced bits always yield a valid char
     const bitsMuncher = () => {
-      fillEntropy(entropyBits, entropyFunction)
-      const entropyOffset = entropyBits[0]
-      // eslint-disable-next-line functional/immutable-data
-      entropyBits[0] = entropyOffset + nBitsPerPuid
+      entropyOffset = fillEntropy(entropyOffset, entropyBuffer, entropyFunction)
       const codes = mapper.map((ndx: number) =>
         charsEncoder(valueAt(entropyOffset + ndx * nBitsPerChar, nBitsPerChar, entropyBytes))
       )
+      entropyOffset += nBitsPerPuid
       return String.fromCharCode(...codes)
     }
 
@@ -184,14 +179,13 @@ export default (puidLen: number, puidChars: string, entropyFunction: EntropyFunc
   }
 
   const sliceValue = () => {
-    if (nEntropyBits < entropyBits[0] + nBitsPerChar) {
-      fillEntropy(entropyBits, entropyFunction)
+    if (nEntropyBits < entropyOffset + nBitsPerChar) {
+      entropyOffset = fillEntropy(entropyOffset, entropyBuffer, entropyFunction)
     }
 
-    const slicedValue = valueAt(entropyBits[0], nBitsPerChar, entropyBytes)
+    const slicedValue = valueAt(entropyOffset, nBitsPerChar, entropyBytes)
     const [accept, shift] = acceptValue(slicedValue)
-    // eslint-disable-next-line functional/immutable-data
-    entropyBits[0] += shift
+    entropyOffset += shift
 
     if (accept) {
       return charsEncoder(slicedValue)

src/types/puid.d.ts

@@ -38,7 +38,6 @@ type PuidBitsMuncherResult = Either<PuidBitsMuncher>
 type PuidBitsSlicer = (puidBits: PuidBits) => number[]
 type PuidEncoder = (n: number) => number
 
-type EntropyBits = [offset: number, buffer: EntropyBuffer]
 type EntropyBytes = Uint8Array
 type EntropyBuffer = ArrayBuffer