feat(uuid): adding util functions to generate uuid

src/utils/generateUUID.test.ts

@@ -0,0 +1,9 @@
+import { generateUUID } from './generateUUID';
+
+describe('generateUUID', () => {
+  it('should generate a valid UUID', () => {
+    const uuid = generateUUID();
+    const RFC4122 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+    expect(RFC4122.test(uuid)).toEqual(true);
+  });
+});

src/utils/generateUUID.ts

@@ -0,0 +1,21 @@
+import { MersenneTwister } from './mersenneTwister';
+
+/**
+ * uuid
+ *
+ * @method faker.random.uuid
+ */
+const replacePlaceholders = (placeholder: string): string => {
+  const mersenne = new MersenneTwister();
+  const random = Math.floor(mersenne.randomInt() * (1.0 / 4294967296.0) * 15);
+  // Workaround problem in Float point arithmetics for e.g. 6681493 / 0.01
+
+  const value = placeholder === 'x' ? random : (random & 0x3) | 0x8;
+  return value.toString(16);
+};
+
+export function generateUUID(): string {
+  const RFC4122_TEMPLATE = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
+
+  return RFC4122_TEMPLATE.replace(/[xy]/g, replacePlaceholders);
+}

src/utils/mersenneTwister.test.ts

@@ -0,0 +1,61 @@
+import { MersenneTwister } from './mersenneTwister';
+
+describe('MersenneTwister', () => {
+  it('Should repeat random sequence on same seed', () => {
+    const g = new MersenneTwister();
+
+    const seed = 123;
+
+    g.initSeed(seed);
+    const first1 = g.random();
+    const first2 = g.random();
+
+    g.initSeed(seed);
+    const second1 = g.random();
+    const second2 = g.random();
+
+    expect(first1).toEqual(second1);
+    expect(first2).toEqual(second2);
+  });
+
+  it('Should allow seeding via constructor', () => {
+    const seed = 325;
+    const g1 = new MersenneTwister(seed);
+    const g2 = new MersenneTwister(seed);
+
+    for (let i = 0; i < 5; ++i) {
+      expect(g1.random()).toEqual(g2.random());
+    }
+  });
+
+  it('Should roughly match Python when seeded by array', () => {
+    const seed1 = 0;
+    const seed2 = 42;
+
+    const g1 = new MersenneTwister([seed1]);
+    const g2 = new MersenneTwister([seed2]);
+
+    /* We should get a near exact match with Python's rng
+                 * when we seed by array.  The code for generating
+                 * these comparison values is something like:
+                 import random
+                 r = random.Random(0)
+                 for i in range(10000000):
+                     x = r.random()
+                     if i % 1000000 == 0: print(x)
+                */
+    const values1 = [0.84442, 0.34535, 0.2557, 0.32368, 0.89075];
+    const values2 = [0.63942, 0.55564, 0.55519, 0.81948, 0.94333];
+
+    for (let i = 0; i < 5000000; i++) {
+      const rval1 = g1.randomLong();
+      const rval2 = g2.randomLong();
+
+      if (i % 1000000 === 0) {
+        const idx = i / 1000000;
+        expect(rval1).toBeCloseTo(values1[idx], 4);
+        expect(rval2).toBeCloseTo(values2[idx], 4);
+      }
+    }
+  });
+});

src/utils/mersenneTwister.ts

@@ -0,0 +1,226 @@
+/*
+  https://github.com/banksean wrapped Makoto Matsumoto and Takuji Nishimura's code in a namespace
+  so it's better encapsulated. Now you can have multiple random number generators
+  and they won't stomp all over each other's state.
+  If you want to use this as a substitute for Math.random(), use the random()
+  method like so:
+  var m = new MersenneTwister();
+  var randomNumber = m.random();
+  You can also call the other genrand_{foo}() methods on the instance.
+  If you want to use a specific seed in order to get a repeatable random
+  sequence, pass an integer into the constructor:
+  var m = new MersenneTwister(123);
+  and that will always produce the same random sequence.
+  Sean McCullough (banksean@gmail.com)
+*/
+
+/*
+   A C-program for MT19937, with initialization improved 2002/1/26.
+   Coded by Takuji Nishimura and Makoto Matsumoto.
+   Before using, initialize the state by using init_seed(seed)
+   or init_by_array(init_key, key_length).
+   Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+   All rights reserved.
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+     1. Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+     2. Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in the
+        documentation and/or other materials provided with the distribution.
+     3. The names of its contributors may not be used to endorse or promote
+        products derived from this software without specific prior written
+        permission.
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   Any feedback is very welcome.
+   http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
+   email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
+*/
+
+export class MersenneTwister {
+  private readonly N: number;
+  private readonly M: number;
+  private readonly MATRIX_A: number;
+  private readonly UPPER_MASK: number;
+  private readonly LOWER_MASK: number;
+  private readonly mt: number[];
+  private mti: number;
+
+  constructor(seed?: number | number[]) {
+    /* Period parameters */
+    this.N = 624;
+    this.M = 397;
+    this.MATRIX_A = 0x9908b0df; /* constant vector a */
+    this.UPPER_MASK = 0x80000000; /* most significant w-r bits */
+    this.LOWER_MASK = 0x7fffffff; /* least significant r bits */
+
+    this.mt = new Array(this.N); /* the array for the state vector */
+    this.mti = this.N + 1; /* mti==N+1 means mt[N] is not initialized */
+
+    if (Array.isArray(seed)) {
+      this.initByArray(seed, seed.length);
+    } else {
+      if (seed === undefined) {
+        this.initSeed(new Date().getTime());
+      } else {
+        this.initSeed(seed);
+      }
+    }
+  }
+
+  /* initializes mt[N] with a seed */
+  /* origin name init_genrand */
+
+  initSeed(seed: number): void {
+    this.mt[0] = seed >>> 0;
+    for (this.mti = 1; this.mti < this.N; this.mti++) {
+      const s = this.mt[this.mti - 1] ^ (this.mt[this.mti - 1] >>> 30);
+      this.mt[this.mti] =
+        ((((s & 0xffff0000) >>> 16) * 1812433253) << 16) +
+        (s & 0x0000ffff) * 1812433253 +
+        this.mti;
+      /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
+      /* In the previous versions, MSBs of the seed affect   */
+      /* only MSBs of the array mt[].                        */
+      /* 2002/01/09 modified by Makoto Matsumoto             */
+      this.mt[this.mti] >>>= 0;
+      /* for >32 bit machines */
+    }
+  }
+
+  /* initialize by an array with array-length */
+  /* init_key is the array for initializing keys */
+  /* key_length is its length */
+  /* slight change for C++, 2004/2/26 */
+  private initByArray(initKey: number[], keyLength: number): void {
+    this.initSeed(19650218);
+    let i = 1;
+    let j = 0;
+    let k = this.N > keyLength ? this.N : keyLength;
+    for (; k; k--) {
+      const s = this.mt[i - 1] ^ (this.mt[i - 1] >>> 30);
+      this.mt[i] =
+        (this.mt[i] ^
+          (((((s & 0xffff0000) >>> 16) * 1664525) << 16) +
+            (s & 0x0000ffff) * 1664525)) +
+        initKey[j] +
+        j; /* non linear */
+      this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */
+      i++;
+      j++;
+      if (i >= this.N) {
+        this.mt[0] = this.mt[this.N - 1];
+        i = 1;
+      }
+      if (j >= keyLength) j = 0;
+    }
+    for (k = this.N - 1; k; k--) {
+      const s = this.mt[i - 1] ^ (this.mt[i - 1] >>> 30);
+      this.mt[i] =
+        (this.mt[i] ^
+          (((((s & 0xffff0000) >>> 16) * 1566083941) << 16) +
+            (s & 0x0000ffff) * 1566083941)) -
+        i; /* non linear */
+      this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */
+      i++;
+      if (i >= this.N) {
+        this.mt[0] = this.mt[this.N - 1];
+        i = 1;
+      }
+    }
+
+    this.mt[0] = 0x80000000; /* MSB is 1; assuring non-zero initial array */
+  }
+
+  /* generates a random number on [0,0xffffffff]-interval */
+  /* origin name genrand_int32 */
+  randomInt(): number {
+    let y;
+    const mag01 = [0x0, this.MATRIX_A];
+    /* mag01[x] = x * MATRIX_A  for x=0,1 */
+
+    if (this.mti >= this.N) {
+      /* generate N words at one time */
+      let kk;
+
+      if (this.mti === this.N + 1)
+        /* if init_seed() has not been called, */
+        this.initSeed(5489); /* a default initial seed is used */
+
+      for (kk = 0; kk < this.N - this.M; kk++) {
+        y =
+          (this.mt[kk] & this.UPPER_MASK) | (this.mt[kk + 1] & this.LOWER_MASK);
+        this.mt[kk] = this.mt[kk + this.M] ^ (y >>> 1) ^ mag01[y & 0x1];
+      }
+      for (; kk < this.N - 1; kk++) {
+        y =
+          (this.mt[kk] & this.UPPER_MASK) | (this.mt[kk + 1] & this.LOWER_MASK);
+        this.mt[kk] =
+          this.mt[kk + (this.M - this.N)] ^ (y >>> 1) ^ mag01[y & 0x1];
+      }
+      y =
+        (this.mt[this.N - 1] & this.UPPER_MASK) |
+        (this.mt[0] & this.LOWER_MASK);
+      this.mt[this.N - 1] = this.mt[this.M - 1] ^ (y >>> 1) ^ mag01[y & 0x1];
+
+      this.mti = 0;
+    }
+
+    y = this.mt[this.mti++];
+
+    /* Tempering */
+    y ^= y >>> 11;
+    y ^= (y << 7) & 0x9d2c5680;
+    y ^= (y << 15) & 0xefc60000;
+    y ^= y >>> 18;
+
+    return y >>> 0;
+  }
+
+  /* generates a random number on [0,0x7fffffff]-interval */
+  /* origin name genrand_int31 */
+  randomInt31(): number {
+    return this.randomInt() >>> 1;
+  }
+
+  /* generates a random number on [0,1]-real-interval */
+  /* origin name genrand_real1 */
+  randomIncl(): number {
+    return this.randomInt() * (1.0 / 4294967295.0);
+    /* divided by 2^32-1 */
+  }
+
+  /* generates a random number on [0,1)-real-interval */
+  random(): number {
+    return this.randomInt() * (1.0 / 4294967296.0);
+    /* divided by 2^32 */
+  }
+
+  /* generates a random number on (0,1)-real-interval */
+  /* origin name genrand_real3 */
+  randomExcl(): number {
+    return (this.randomInt() + 0.5) * (1.0 / 4294967296.0);
+    /* divided by 2^32 */
+  }
+
+  /* generates a random number on [0,1) with 53-bit resolution*/
+  /* origin name genrand_res53 */
+  randomLong(): number {
+    const a = this.randomInt() >>> 5;
+    const b = this.randomInt() >>> 6;
+    return (a * 67108864.0 + b) * (1.0 / 9007199254740992.0);
+  }
+}
+
+/* These real versions are due to Isaku Wada, 2002/01/09 added */