test: no need to filter MersenneModule anymore

refactor!: simplify mersenne functions

chore: add @internal tag

chore: cant use `@internal` types

chore: need to import type via relative

chore: revert changes to do them in separate PR

Author: Shinigami92

src/faker.ts

@@ -1,7 +1,6 @@
 import type { LocaleDefinition } from './definitions';
 import { FakerError } from './errors/faker-error';
-import type { Mersenne } from './internal/mersenne/mersenne';
-import mersenne from './internal/mersenne/mersenne';
+import { MersenneModule } from './internal/mersenne/mersenne';
 import type { KnownLocale } from './locales';
 import { AddressModule } from './modules/address';
 import { AnimalModule } from './modules/animal';
@@ -76,7 +75,7 @@ export class Faker {
   readonly definitions: LocaleDefinition = this.initDefinitions();
 
   /** @internal */
-  private readonly _mersenne: Mersenne = mersenne();
+  private readonly _mersenne: MersenneModule = new MersenneModule();
 
   readonly random: RandomModule = new RandomModule(this);
 
@@ -241,7 +240,7 @@ export class Faker {
     seed: number | number[] = Math.ceil(Math.random() * Number.MAX_SAFE_INTEGER)
   ): number | number[] {
     if (Array.isArray(seed) && seed.length) {
-      this._mersenne.seedArray(seed);
+      this._mersenne.seed_array(seed);
     } else if (!Array.isArray(seed) && !isNaN(seed)) {
       this._mersenne.seed(seed);
     }

src/internal/mersenne/mersenne.ts

@@ -1,16 +1,47 @@
 import { FakerError } from '../../errors/faker-error';
-import Twister from './twister';
+import Gen from './twister';
+
+/**
+ * Module to generate seed based random numbers.
+ *
+ * @internal
+ */
+export class MersenneModule {
+  private gen = new Gen();
+
+  constructor() {
+    this.gen.initGenrand(Math.ceil(Math.random() * Number.MAX_SAFE_INTEGER));
+
+    // Bind `this` so namespaced is working correctly
+    for (const name of Object.getOwnPropertyNames(MersenneModule.prototype)) {
+      if (name === 'constructor' || typeof this[name] !== 'function') {
+        continue;
+      }
+      this[name] = this[name].bind(this);
+    }
+  }
 
-export interface Mersenne {
   /**
    * Generates a random number between `[min, max)`.
    *
    * @param max The maximum number. Defaults to `32768`.
    * @param min The minimum number. Defaults to `0`.
    *
+   * @example
+   * faker.mersenne.rand() // 15515
+   * faker.mersenne.rand(1000, 500) // 578
+   *
    * @since 5.5.0
    */
-  rand(max?: number, min?: number): number;
+  rand(max = 32768, min = 0): number {
+    if (min > max) {
+      const temp = min;
+      min = max;
+      max = temp;
+    }
+
+    return Math.floor(this.gen.genrandReal2() * (max - min) + min);
+  }
 
   /**
    * Sets the seed to use.
@@ -20,7 +51,15 @@ export interface Mersenne {
    *
    * @since 5.5.0
    */
-  seed(S: number): void;
+  seed(S: number): void {
+    if (typeof S !== 'number') {
+      throw new FakerError(
+        `seed(S) must take numeric argument; is ${typeof S}`
+      );
+    }
+
+    this.gen.initGenrand(S);
+  }
 
   /**
    * Sets the seed to use.
@@ -30,48 +69,13 @@ export interface Mersenne {
    *
    * @since 5.5.0
    */
-  seedArray(A: number[]): void;
-}
-
-/**
- * Generate seed based random numbers.
- *
- * @internal
- */
-export default function mersenne(): Mersenne {
-  const twister = new Twister();
-
-  twister.initGenrand(Math.ceil(Math.random() * Number.MAX_SAFE_INTEGER));
-
-  return {
-    rand(max = 32768, min = 0): number {
-      if (min > max) {
-        const temp = min;
-        min = max;
-        max = temp;
-      }
-
-      return Math.floor(twister.genrandReal2() * (max - min) + min);
-    },
-
-    seed(S: number): void {
-      if (typeof S !== 'number') {
-        throw new FakerError(
-          `seed(S) must take numeric argument; is ${typeof S}`
-        );
-      }
-
-      twister.initGenrand(S);
-    },
-
-    seedArray(A: number[]): void {
-      if (typeof A !== 'object') {
-        throw new FakerError(
-          `seedArray(A) must take array of numbers; is ${typeof A}`
-        );
-      }
+  seed_array(A: number[]): void {
+    if (typeof A !== 'object') {
+      throw new FakerError(
+        `seed_array(A) must take array of numbers; is ${typeof A}`
+      );
+    }
 
-      twister.initByArray(A, A.length);
-    },
-  };
+    this.gen.initByArray(A, A.length);
+  }
 }

src/modules/datatype/index.ts

@@ -1,5 +1,6 @@
 import type { Faker } from '../..';
 import { FakerError } from '../../errors/faker-error';
+import type { MersenneModule } from '../../internal/mersenne/mersenne';
 
 /**
  * Module to generate various primitive values and data types.
@@ -54,7 +55,7 @@ export class DatatypeModule {
       throw new FakerError(`Max ${max} should be greater than min ${min}.`);
     }
 
-    const mersenne =
+    const mersenne: MersenneModule =
       // @ts-expect-error: access private member field
       this.faker._mersenne;
 

test/mersenne.spec.ts

@@ -1,7 +1,6 @@
 import { beforeAll, beforeEach, describe, expect, it } from 'vitest';
 import { FakerError } from '../src/errors/faker-error';
-import type { Mersenne } from '../src/internal/mersenne/mersenne';
-import mersenneFn from '../src/internal/mersenne/mersenne';
+import { MersenneModule } from '../src/internal/mersenne/mersenne';
 import { seededRuns } from './support/seededRuns';
 
 const minMaxTestCases = [
@@ -15,17 +14,17 @@ const functionNames = ['rand'];
 const NON_SEEDED_BASED_RUN = 25;
 
 describe('mersenne twister', () => {
-  let mersenne: Mersenne;
+  let mersenne: MersenneModule;
 
   beforeEach(() => {
-    mersenne = mersenneFn();
+    mersenne = new MersenneModule();
   });
 
   for (const seed of [...seededRuns, [42, 1, 2], [1337, 1, 2], [1211, 1, 2]]) {
     describe(`seed: ${JSON.stringify(seed)}`, () => {
       beforeEach(() => {
         if (Array.isArray(seed)) {
-          mersenne.seedArray(seed);
+          mersenne.seed_array(seed);
         } else {
           mersenne.seed(seed);
         }
@@ -68,7 +67,7 @@ describe('mersenne twister', () => {
     describe(`random seeded tests ${JSON.stringify(seed)}`, () => {
       beforeAll(() => {
         if (Array.isArray(seed)) {
-          mersenne.seedArray(seed);
+          mersenne.seed_array(seed);
         } else {
           mersenne.seed(seed);
         }
@@ -105,12 +104,12 @@ describe('mersenne twister', () => {
 
   it('should throw an error when attempting to seed() a non-integer', () => {
     expect(() =>
-      mersenne.seedArray(
+      mersenne.seed_array(
         // @ts-expect-error: non-integer error
         'abc'
       )
     ).toThrowError(
-      new FakerError('seedArray(A) must take array of numbers; is string')
+      new FakerError('seed_array(A) must take array of numbers; is string')
     );
   });
 });

test/scripts/apidoc/examplesAndDeprecations.spec.ts

@@ -32,15 +32,13 @@ describe('examples and deprecations', () => {
 
   const modules: Record<string, DeclarationReflection[]> = selectApiModules(
     project
-  )
-    .filter((module) => module.name !== 'MersenneModule')
-    .reduce(
-      (a, v) => ({
-        ...a,
-        [v.name]: v.getChildrenByKind(ReflectionKind.Method),
-      }),
-      {}
-    );
+  ).reduce(
+    (a, v) => ({
+      ...a,
+      [v.name]: v.getChildrenByKind(ReflectionKind.Method),
+    }),
+    {}
+  );
 
   const consoleSpies: Array<SpyInstance> = Object.keys(console)
     .filter((key) => typeof console[key] === 'function')