Generator now only have one abstract method, while self handling the calculation of characters. Specific generators now implements getRandom.

Author: Johannestegner

src/Generator.js

@@ -1,29 +1,51 @@
+import { randomBytes } from "crypto";
+
 export default class Generator {
+
+  /**
+   * @internal
+   * @abstract
+   * @param {number} len Length of list.
+   * @return {Uint8Array} List of random values.
+   */
+  getRandom (len) {}
+
   /**
    * Fetch a list of random char codes for alpha characters.
    *
-   * @abstract
    * @param {number} len Amount of alpha characters to fetch.
-   * @return {Array<number>} An array with char-codes (ascii) for the random alpha characters.
+   * @return {Uint8Array} An array with char-codes (ascii) for the random alpha characters.
    */
-  alpha (len) {}
+  alpha (len) {
+    return this.getRandom(len).map(i => (Math.round(i % 25) + (i > 128 ? 65 : 97)));
+  }
 
   /**
    * Fetch a list of random char codes of numeric characters.
    *
-   * @abstract
    * @param {number} len Amount of number characters to fetch.
-   * @return {Array<number>} An array with char-codes (ascii) for the random numeric characters.
+   * @return {Uint8Array} An array with char-codes (ascii) for the random numeric characters.
    */
-  numbers (len) {}
+  numbers (len) {
+    return this.getRandom(len).map(i => (Math.round(i % 10) + 48));
+  }
 
 
   /**
    * Fetch a list of random char codes of special characters.
    *
-   * @abstract
    * @param {number} len Amount of special characters to fetch.
-   * @return {Array<number>} An array with char-codes (ascii) for the random special characters.
+   * @return {Uint8Array} An array with char-codes (ascii) for the random special characters.
    */
-  special (len) {}
+  special (len) {
+    return this.getRandom(len).map(i => {
+      return i < 32
+        ? Math.round(i % 15) + 33
+        : i < 65
+          ? Math.round(i % 7) + 58
+          : i < 128
+            ? Math.round(i % 4) + 91
+            : Math.round(i % 4) + 123;
+    });
+  }
 }

src/NodeGenerator.js

@@ -0,0 +1,9 @@
+import Generator from './Generator';
+import { randomBytes } from 'crypto';
+
+export default class NodeGenerator extends Generator {
+
+  getRandom (len) {
+    return randomBytes(len);
+  }
+}

src/WebGenerator.js

@@ -0,0 +1,19 @@
+import Generator from './Generator';
+
+export default class WebGenerator extends Generator {
+
+  getRandom (len) {
+    const list = new Uint8Array(len);
+    if (window.crypto) {
+      window.crypto.getRandomValues(list);
+      return list;
+    }
+
+    // Fallback to random if no crypto on window.
+    for (let i = 0; i < len; i++) {
+      list[i] = Math.random();
+    }
+
+    return list;
+  }
+}

src/node.js

@@ -0,0 +1,8 @@
+import rand from './rand';
+
+const generator = () => {
+
+
+};
+
+export default rand(generator);

src/rand.js

@@ -0,0 +1,41 @@
+import { shuffle } from './Util'
+
+export default (generator) => (length, options = {
+  alpha: true,
+  numbers: true,
+  special: true,
+  minAlpha: 1,
+  minNumbers: 1,
+  minSpecial: 1,
+}) => {
+
+  const lists = {
+    alpha:   (options.alpha   ? generator.alpha(length)   : []),
+    special: (options.special ? generator.special(length) : []),
+    numbers: (options.numbers ? generator.numbers(length) : []),
+    combined: []
+  };
+
+  const result = [];
+  result.push(...lists.alpha.splice(0, options.minAlpha));
+  result.push(...lists.special.splice(0, options.minSpecial));
+  result.push(...lists.numbers.splice(0, options.numbers));
+
+  lists.combined = shuffle([].concat(
+    ...lists.alpha,
+    ...lists.special,
+    ...lists.numbers)
+  );
+
+  // Concat rest.
+  result.push(lists.combined.splice(0, length - (
+    (options.special ? options.minSpecial : 0)
+    +
+    (options.alpha ? options.minAlpha : 0)
+    +
+    (options.numbers ? options.minNumbers : 0)
+  )));
+
+  return shuffle(result);
+}
+