Remove CharSet use of WeakMap

dingosky · dingosky · commit 5938449dd4cb · 2018-06-06T13:09:27.000-07:00
diff --git a/dist/entropy-string.js b/dist/entropy-string.js
@@ -16,8 +16,11 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 
 var WeakMap = require('weak-map');
 
-var csprngBytes = require('lib/csprng-bytes');
-var prngBytes = require('lib/prng-bytes');
+var _require = require('./lib/csprng-bytes'),
+    csprngBytes = _require.csprngBytes;
+
+var _require2 = require('./lib/prng-bytes'),
+    prngBytes = _require2.prngBytes;
 
 var BITS_PER_BYTE = 8;
 var abs = Math.abs,
@@ -92,7 +95,9 @@ var CharSet = function () {
     if (![2, 4, 8, 16, 32, 64].includes(length)) {
       throw new Error('Invalid char count: must be one of 2,4,8,16,32,64');
     }
-    var bitsPerChar = floor(log2(length));
+
+    this.bitsPerChar = floor(log2(length));
+
     // Ensure no repeated characters
     for (var i = 0; i < length; i += 1) {
       var c = chars.charAt(i);
@@ -104,10 +109,9 @@ var CharSet = function () {
     }
     var privProps = {
       chars: chars,
-      bitsPerChar: bitsPerChar,
       length: length,
-      ndxFn: genNdxFn(bitsPerChar),
-      charsPerChunk: lcm(bitsPerChar, BITS_PER_BYTE) / bitsPerChar
+      ndxFn: genNdxFn(this.bitsPerChar),
+      charsPerChunk: lcm(this.bitsPerChar, BITS_PER_BYTE) / this.bitsPerChar
     };
     charsetProps.set(this, privProps);
   }
@@ -120,7 +124,7 @@ var CharSet = function () {
   }, {
     key: 'getBitsPerChar',
     value: function getBitsPerChar() {
-      return charsetProps.get(this).bitsPerChar;
+      return this.bitsPerChar;
     }
   }, {
     key: 'getNdxFn',
@@ -140,8 +144,8 @@ var CharSet = function () {
   }, {
     key: 'bytesNeeded',
     value: function bytesNeeded(bitLen) {
-      var count = ceil(bitLen / this.bitsPerChar());
-      return ceil(count * this.bitsPerChar() / BITS_PER_BYTE);
+      var count = ceil(bitLen / this.bitsPerChar);
+      return ceil(count * this.bitsPerChar / BITS_PER_BYTE);
     }
 
     // Aliases
@@ -156,11 +160,8 @@ var CharSet = function () {
     value: function ndxFn() {
       return this.getNdxFn();
     }
-  }, {
-    key: 'bitsPerChar',
-    value: function bitsPerChar() {
-      return this.getBitsPerChar();
-    }
+    // bitsPerChar() { return this.getBitsPerChar() }
+
   }]);
   return CharSet;
 }();
@@ -177,7 +178,7 @@ var _stringWithBytes = function _stringWithBytes(bytes, bitLen, charset) {
     return '';
   }
 
-  var bitsPerChar = charset.getBitsPerChar();
+  var bitsPerChar = charset.bitsPerChar;
   var count = ceil(bitLen / bitsPerChar);
   if (count <= 0) {
     return '';
@@ -209,28 +210,6 @@ var _stringWithBytes = function _stringWithBytes(bytes, bitLen, charset) {
   return string;
 };
 
-// const csprngBytes = count => Buffer.from(Crypto.randomBytes(count))
-
-// const prngBytes = (count) => {
-//   console.log('CxDebug prng: true')
-//   const BYTES_USED_PER_RANDOM_CALL = 6
-//   const randCount = ceil(count / BYTES_USED_PER_RANDOM_CALL)
-
-//   const buffer = new ArrayBuffer(count)
-//   const dataView = new DataView(new ArrayBuffer(BITS_PER_BYTE))
-//   for (let rNum = 0; rNum < randCount; rNum += 1) {
-//     dataView.setFloat64(0, random())
-//     for (let n = 0; n < BYTES_USED_PER_RANDOM_CALL; n += 1) {
-//       const fByteNum = endianByteNum[n]
-//       const bByteNum = (rNum * BYTES_USED_PER_RANDOM_CALL) + n
-//       if (bByteNum < count) {
-//         buffer[bByteNum] = dataView.getUint8(fByteNum)
-//       }
-//     }
-//   }
-//   return buffer
-// }
-
 var entropyBits = function entropyBits(total, risk) {
   if (total === 0) {
     return 0;
diff --git a/dist/lib/csprng-bytes-browser.js b/dist/lib/csprng-bytes-browser.js
@@ -0,0 +1,9 @@
+"use strict";
+
+var csprngBytes = function csprngBytes(count) {
+  return window.crypto.getRandomValues(new Uint8Array(count));
+};
+
+module.exports = {
+  csprngBytes: csprngBytes
+};
diff --git a/dist/lib/prng-bytes.js b/dist/lib/prng-bytes.js
@@ -1,6 +1,7 @@
-'use strict';
+"use strict";
 
-var random = Math.random;
+var ceil = Math.ceil,
+    random = Math.random;
 
 
 var BITS_PER_BYTE = 8;
@@ -13,7 +14,6 @@ var endianByteNum = function () {
 }();
 
 var prngBytes = function prngBytes(count) {
-  console.log('CxDebug prng: true');
   var BYTES_USED_PER_RANDOM_CALL = 6;
   var randCount = ceil(count / BYTES_USED_PER_RANDOM_CALL);
 
diff --git a/entropy-string.js b/entropy-string.js
@@ -55,7 +55,6 @@ const genNdxFn = (bitsPerChar) => {
   }
 }
 
-const charsetProps = new WeakMap()
 class CharSet {
   constructor(chars) {
     if (!(typeof chars === 'string' || chars instanceof String)) {
@@ -65,7 +64,7 @@ class CharSet {
     if (![2, 4, 8, 16, 32, 64].includes(length)) {
       throw new Error('Invalid char count: must be one of 2,4,8,16,32,64')
     }
-    const bitsPerChar = floor(log2(length))
+
     // Ensure no repeated characters
     for (let i = 0; i < length; i += 1) {
       const c = chars.charAt(i)
@@ -75,45 +74,18 @@ class CharSet {
         }
       }
     }
-    const privProps = {
-      chars,
-      bitsPerChar,
-      length,
-      ndxFn: genNdxFn(bitsPerChar),
-      charsPerChunk: lcm(bitsPerChar, BITS_PER_BYTE) / bitsPerChar
-    }
-    charsetProps.set(this, privProps)
-  }
-
-  getChars() {
-    return charsetProps.get(this).chars
-  }
-
-  getBitsPerChar() {
-    return charsetProps.get(this).bitsPerChar
-  }
 
-  getNdxFn() {
-    return charsetProps.get(this).ndxFn
-  }
-
-  getCharsPerChunk() {
-    return charsetProps.get(this).charsPerChunk
-  }
-
-  length() {
-    return charsetProps.get(this).length
+    this.chars = chars
+    this.bitsPerChar = floor(log2(length))
+    this.length = length
+    this.ndxFn = genNdxFn(this.bitsPerChar)
+    this.charsPerChunk = lcm(this.bitsPerChar, BITS_PER_BYTE) / this.bitsPerChar
   }
 
   bytesNeeded(bitLen) {
-    const count = ceil(bitLen / this.bitsPerChar())
-    return ceil((count * this.bitsPerChar()) / BITS_PER_BYTE)
+    const count = ceil(bitLen / this.bitsPerChar)
+    return ceil((count * this.bitsPerChar) / BITS_PER_BYTE)
   }
-
-  // Aliases
-  chars() { return this.getChars() }
-  ndxFn() { return this.getNdxFn() }
-  bitsPerChar() { return this.getBitsPerChar() }
 }
 
 const charset64 = new CharSet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_')
@@ -126,7 +98,7 @@ const charset2 = new CharSet('01')
 const stringWithBytes = (bytes, bitLen, charset) => {
   if (bitLen <= 0) { return '' }
 
-  const bitsPerChar = charset.getBitsPerChar()
+  const { bitsPerChar } = charset
   const count = ceil(bitLen / bitsPerChar)
   if (count <= 0) { return '' }
 
@@ -135,13 +107,11 @@ const stringWithBytes = (bytes, bitLen, charset) => {
     throw new Error(`Insufficient bytes: need ${need} and got ${bytes.length}`)
   }
 
-  const charsPerChunk = charset.getCharsPerChunk()
+  const { ndxFn, charsPerChunk, chars } = charset
+
   const chunks = floor(count / charsPerChunk)
   const partials = count % charsPerChunk
 
-  const ndxFn = charset.getNdxFn()
-  const chars = charset.getChars()
-
   let string = ''
   for (let chunk = 0; chunk < chunks; chunk += 1) {
     for (let slice = 0; slice < charsPerChunk; slice += 1) {
@@ -289,7 +259,7 @@ class Entropy {
   }
 
   chars() {
-    return entropyProps.get(this).charset.chars()
+    return entropyProps.get(this).charset.chars
   }
 
   bits() {
diff --git a/tests/charset.js b/tests/charset.js
@@ -5,56 +5,56 @@ const {
 
 test('charset64', () => {
   const charset = new CharSet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_')
-  const { length } = charset.getChars()
+  const { length } = charset.chars
   expect(length).toBe(64)
   const bitsPerChar = Math.log2(length)
-  expect(charset.getBitsPerChar()).toBe(bitsPerChar)
-  expect(charset.getCharsPerChunk()).toBe(4)
+  expect(charset.bitsPerChar).toBe(bitsPerChar)
+  expect(charset.charsPerChunk).toBe(4)
 })
 
 test('charset32', () => {
   const charset = new CharSet('2346789bdfghjmnpqrtBDFGHJLMNPQRT')
-  const { length } = charset.getChars()
+  const { length } = charset.chars
   expect(length).toBe(32)
   const bitsPerChar = Math.log2(length)
-  expect(charset.getBitsPerChar()).toBe(bitsPerChar)
-  expect(charset.getCharsPerChunk()).toBe(8)
+  expect(charset.bitsPerChar).toBe(bitsPerChar)
+  expect(charset.charsPerChunk).toBe(8)
 })
 
 test('charset16', () => {
   const charset = new CharSet('0123456789abcdef')
-  const { length } = charset.getChars()
+  const { length } = charset.chars
   expect(length).toBe(16)
   const bitsPerChar = Math.log2(length)
-  expect(charset.getBitsPerChar()).toBe(bitsPerChar)
-  expect(charset.getCharsPerChunk()).toBe(2)
+  expect(charset.bitsPerChar).toBe(bitsPerChar)
+  expect(charset.charsPerChunk).toBe(2)
 })
 
 test('charset8', () => {
   const charset = new CharSet('01234567')
-  const { length } = charset.getChars()
+  const { length } = charset.chars
   expect(length).toBe(8)
   const bitsPerChar = Math.log2(length)
-  expect(charset.getBitsPerChar()).toBe(bitsPerChar)
-  expect(charset.getCharsPerChunk()).toBe(8)
+  expect(charset.bitsPerChar).toBe(bitsPerChar)
+  expect(charset.charsPerChunk).toBe(8)
 })
 
 test('charset4', () => {
   const charset = new CharSet('ATCG')
-  const { length } = charset.getChars()
+  const { length } = charset.chars
   expect(length).toBe(4)
   const bitsPerChar = Math.log2(length)
-  expect(charset.getBitsPerChar()).toBe(bitsPerChar)
-  expect(charset.getCharsPerChunk()).toBe(4)
+  expect(charset.bitsPerChar).toBe(bitsPerChar)
+  expect(charset.charsPerChunk).toBe(4)
 })
 
 test('charset2', () => {
   const charset = new CharSet('01')
-  const { length } = charset.getChars()
+  const { length } = charset.chars
   expect(length).toBe(2)
   const bitsPerChar = Math.log2(length)
-  expect(charset.getBitsPerChar()).toBe(bitsPerChar)
-  expect(charset.getCharsPerChunk()).toBe(8)
+  expect(charset.bitsPerChar).toBe(bitsPerChar)
+  expect(charset.charsPerChunk).toBe(8)
 })
 
 test('Custom chars: 64', () => {
diff --git a/tests/entropy.js b/tests/entropy.js
@@ -11,27 +11,27 @@ const rbits = (t, r) => round(Entropy.bits(t, r))
 test('Entropy constructor', () => {
   let entropy = new Entropy()
   expect(entropy.bits()).toBe(128)
-  expect(entropy.chars()).toBe(charset32.chars())
+  expect(entropy.chars()).toBe(charset32.chars)
   expect(entropy.bytesNeeded()).toBe(17)
 
   entropy = new Entropy({ bits: 32 })
   expect(entropy.bits()).toBe(32)
-  expect(entropy.chars()).toBe(charset32.chars())
+  expect(entropy.chars()).toBe(charset32.chars)
   expect(entropy.bytesNeeded()).toBe(5)
 
   entropy = new Entropy({ total: 1000, risk: 1e9 })
   expect(entropy.bits()).toBe(49)
-  expect(entropy.chars()).toBe(charset32.chars())
+  expect(entropy.chars()).toBe(charset32.chars)
   expect(entropy.bytesNeeded()).toBe(7)
 
   entropy = new Entropy({ bits: 32, charset: charset16 })
   expect(entropy.bits()).toBe(32)
-  expect(entropy.chars()).toBe(charset16.chars())
+  expect(entropy.chars()).toBe(charset16.chars)
   expect(entropy.bytesNeeded()).toBe(4)
 
   entropy = new Entropy({ total: 1e6, risk: 10000000, charset: charset16 })
   expect(entropy.bits()).toBe(62)
-  expect(entropy.chars()).toBe(charset16.chars())
+  expect(entropy.chars()).toBe(charset16.chars)
   expect(entropy.bytesNeeded()).toBe(8)
 })
 
