feat(core): faker as helper function instead of object

Author: Awilum

index.d.ts

@@ -58,6 +58,9 @@ interface OptionsUrl {
     protocol?: string;
     tld?: string;
 }
+interface OptionsFaker {
+    locale?: string;
+}
 declare class Faker {
     boolean(): boolean;
     integer(options?: OptionsInteger): number;
@@ -81,5 +84,4 @@ declare class Faker {
     firstName(options?: OptionsFirstname): string;
     lastName(options?: OptionsLastname): string;
 }
-declare const faker: Faker;
-export default faker;
+export default function faker(options?: OptionsFaker): Faker;

index.js

@@ -21,6 +21,12 @@ import firstName from '@fakerjs/firstname';
 import lastName from '@fakerjs/lastname';
 
 class Faker {
+    options = {};
+
+    constructor(options) {
+        this.options = options || {};
+    }
+
     boolean() {
         return boolean();
     }
@@ -38,27 +44,27 @@ class Faker {
     }
 
     gender(options) {
-        return gender(options);
+        return gender({locale: this.options.locale || 'en_US', ...options});
     }
 
     ip() {
         return ip();
     }
 
     letter(options) {
-        return letter(options);
+        return letter({locale: this.options.locale || 'en_US', ...options});
     }
 
     string(options) {
         return string(options);
     }
 
     profession(options) {
-        return profession(options);
+        return profession({locale: this.options.locale || 'en_US', ...options});
     }
 
     animal(options) {
-        return animal(options);
+        return animal({locale: this.options.locale || 'en_US', ...options});
     }
 
     superhero() {
@@ -86,13 +92,13 @@ class Faker {
     }
 
     firstName(options) {
-        return firstName(options);
+        return firstName({locale: this.options.locale || 'en_US', ...options});
     }
 
     lastName(options) {
-        return lastName(options);
+        return lastName({locale: this.options.locale || 'en_US', ...options});
     }
-    
+
     browser() {
         return browser();
     }
@@ -106,5 +112,6 @@ class Faker {
     }
 }
 
-const faker = new Faker();
-export default faker;
+export default function faker(options) {
+    return new Faker(options);
+}

index.test-d.ts

@@ -1,24 +1,24 @@
 import {expectType} from 'tsd';
 import faker from './index.js';
 
-expectType<boolean>(faker.boolean());
-expectType<number>(faker.age());
-expectType<string>(faker.animal());
-expectType<string>(faker.gender());
-expectType<string>(faker.string());
-expectType<string>(faker.letter());
-expectType<string>(faker.profession());
-expectType<string>(faker.ip());
-expectType<string>(faker.superhero());
-expectType<number>(faker.integer());
-expectType<number>(faker.float());
-expectType<string>(faker.word());
-expectType<string>(faker.sentence());
-expectType<string>(faker.paragraph());
-expectType<string>(faker.domain());
-expectType<string>(faker.url());
-expectType<string>(faker.tld());
-expectType<string>(faker.browser());
-expectType<string>(faker.email());
-expectType<string>(faker.firstName());
-expectType<string>(faker.lastName());
+expectType<boolean>(faker().boolean());
+expectType<number>(faker().age());
+expectType<string>(faker().animal());
+expectType<string>(faker().gender());
+expectType<string>(faker().string());
+expectType<string>(faker().letter());
+expectType<string>(faker().profession());
+expectType<string>(faker().ip());
+expectType<string>(faker().superhero());
+expectType<number>(faker().integer());
+expectType<number>(faker().float());
+expectType<string>(faker().word());
+expectType<string>(faker().sentence());
+expectType<string>(faker().paragraph());
+expectType<string>(faker().domain());
+expectType<string>(faker().url());
+expectType<string>(faker().tld());
+expectType<string>(faker().browser());
+expectType<string>(faker().email());
+expectType<string>(faker().firstName());
+expectType<string>(faker().lastName());

test.js

@@ -2,89 +2,89 @@ import test from 'ava';
 import faker from './index.js';
 
 test('faker return type to be object', t => {
-    t.is(typeof faker, 'object');
+    t.is(typeof faker(), 'object');
 });
 
 test('faker boolean return type to be boolean', t => {
-    t.is(typeof faker.boolean(), 'boolean');
+    t.is(typeof faker().boolean(), 'boolean');
 });
 
 test('faker string return type to be string', t => {
-    t.is(typeof faker.string(), 'string');
+    t.is(typeof faker().string(), 'string');
 });
 
 test('faker age return type to be number', t => {
-    t.is(typeof faker.age(), 'number');
+    t.is(typeof faker().age(), 'number');
 });
 
 test('faker animal return type to be string', t => {
-    t.is(typeof faker.animal(), 'string');
+    t.is(typeof faker().animal(), 'string');
 });
 
 test('faker integer return type to be number', t => {
-    t.is(typeof faker.integer(), 'number');
+    t.is(typeof faker().integer(), 'number');
 });
 
 test('faker float return type to be number', t => {
-    t.is(typeof faker.float(), 'number');
+    t.is(typeof faker().float(), 'number');
 });
 
 test('faker gende return type to be string', t => {
-    t.is(typeof faker.gender(), 'string');
+    t.is(typeof faker().gender(), 'string');
 });
 
 test('faker superhero return type to be string', t => {
-    t.is(typeof faker.superhero(), 'string');
+    t.is(typeof faker().superhero(), 'string');
 });
 
 test('faker profession return type to be string', t => {
-    t.is(typeof faker.profession(), 'string');
+    t.is(typeof faker().profession(), 'string');
 });
 
 test('faker ip return type to be string', t => {
-    t.is(typeof faker.ip(), 'string');
+    t.is(typeof faker().ip(), 'string');
 });
 
 test('faker letter return type to be string', t => {
-    t.is(typeof faker.letter(), 'string');
+    t.is(typeof faker().letter(), 'string');
 });
 
 test('faker word return type to be string', t => {
-    t.is(typeof faker.word(), 'string');
+    t.is(typeof faker().word(), 'string');
 });
 
 test('faker sentence return type to be string', t => {
-    t.is(typeof faker.sentence(), 'string');
+    t.is(typeof faker().sentence(), 'string');
 });
 
 test('faker paragraph return type to be string', t => {
-    t.is(typeof faker.paragraph(), 'string');
+    t.is(typeof faker().paragraph(), 'string');
 });
 
 test('faker domain return type to be string', t => {
-    t.is(typeof faker.domain(), 'string');
+    t.is(typeof faker().domain(), 'string');
 });
 
 test('faker email return type to be string', t => {
-    t.is(typeof faker.email(), 'string');
+    t.is(typeof faker().email(), 'string');
 });
 
 test('faker firstName return type to be string', t => {
-    t.is(typeof faker.firstName(), 'string');
+    t.is(typeof faker().firstName(), 'string');
 });
 
 test('faker lastName return type to be string', t => {
-    t.is(typeof faker.lastName(), 'string');
+    t.is(typeof faker().lastName(), 'string');
 });
 
 test('faker url return type to be string', t => {
-    t.is(typeof faker.url(), 'string');
+    t.is(typeof faker().url(), 'string');
 });
 
 test('faker tld return type to be string', t => {
-    t.is(typeof faker.tld(), 'string');
+    t.is(typeof faker().tld(), 'string');
 });
 
 test('faker browser return type to be string', t => {
-    t.is(typeof faker.browser(), 'string');
-});
+    t.is(typeof faker().browser(), 'string');
+});