Improve documentation and formatting

Author: fsgreco

.github/workflows/publish.yml

@@ -16,4 +16,4 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: Publish package
-        run: npx jsr publish --allow-slow-types
+        run: npx jsr publish 

CONTRIBUTING.md

@@ -21,7 +21,7 @@ I've tried to set a minumum Test-Driven Development (TDD) flow. Before making an
 1. Write a failing test first
 2. Run tests to verify it fails (`deno test --watch`)
 3. Implement the minimum code to make it pass
-5. Refactor if needed
+4. Refactor if needed
 
 ## Pull Request Process
 

README.md

@@ -1,10 +1,11 @@
-# Quick Mock Data Generator 
+# Quick Mock Data Generator
 
 Need test data quickly? This lightweight utility helps you generate realistic mock data in seconds. Choose from common properties like names, emails, and dates, **or define your own generators**. Perfect for prototypes, tests, and demos where you need meaningful data fast.
 
 Built on top of `@faker-js/faker`, it provides a simpler interface while maintaining type safety and full TypeScript support.
 
 Key features:
+
 - 🚀 Quick property selection from common data types
 - 🎯 Generate exactly what you need, nothing more
 - 📦 Zero configuration required
@@ -35,49 +36,49 @@ The `getMocksWith` function allows you to pick from a predefined set of common p
 
 This basically returns a function that will create mock data based on a list of predefined properties.
 
-
 ```typescript
-import { getMocksWith } from "@functions/mock";
+import { getMocksWith } from '@functions/mock'
 
 // Autosuggestion will let you pick the properties you want in your mock objects
-const createRandomUsers = getMocksWith(['name', 'age', 'email']);
+const createRandomUsers = getMocksWith(['name', 'age', 'email'])
 
 // Generate 3 users with only those properties
-const users = createRandomUsers(3);
+const users = createRandomUsers(3)
 ```
 
 ### Generate Mock Data from a Generator
 
 The `getMocksFromGenerator` function lets you define your own data generation logic. You provide an object where each property is a function that generates values. You can mix and match:
+
 - Faker.js functions
 - Your own custom functions
 - Random value generators
 - Fixed value functions
 - Any JavaScript/TypeScript function that returns a value
 
 ```typescript
-import { getMocksFromGenerator } from "@functions/mock";
-import { faker } from "@faker-js/faker";
+import { getMocksFromGenerator } from '@functions/mock'
+import { faker } from '@faker-js/faker'
 
 const yourGenerator = {
-  // Use faker functions directly
-  id: faker.string.uuid,
-  // Your own random logic
-  age: () => Math.floor(Math.random() * 100),
-  // Mix calculated and faker values
-  username: () => `user_${faker.number.int(1000)}`,
-  // Fixed values
-  role: () => 'user',
-  // Complex custom logic
-  status: () => {
-    const statuses = ['active', 'inactive', 'pending'];
-    return statuses[Math.floor(Math.random() * statuses.length)];
-  }
-};
-
-const createRandomObjects = getMocksFromGenerator(yourGenerator);
+	// Use faker functions directly
+	id: faker.string.uuid,
+	// Your own random logic
+	age: () => Math.floor(Math.random() * (100 - 18 + 1)) + 18,
+	// Mix calculated and faker values
+	username: () => `user_${faker.number.int(1000)}`,
+	// Fixed values
+	role: () => 'user',
+	// Complex custom logic
+	status: () => {
+		const statuses = ['active', 'inactive', 'pending']
+		return statuses[Math.floor(Math.random() * statuses.length)]
+	},
+}
+
+const createRandomObjects = getMocksFromGenerator(yourGenerator)
 // TypeScript should infers return types from your generator functions
-const objects = createRandomObjects(5);
+const objects = createRandomObjects(5)
 // objects is typed as Array<{ id: string; name: string; age: number }>
 ```
 

deno.json

@@ -1,24 +1,31 @@
 {
-  "name": "@functions/mock",
-  "description": "Lightweight utility to generate realistic mock data for tests fast.",
-  "version": "1.1.0",
-  "license": "MIT",
-  "exports":"./mod.ts",
-  "tasks": {
-    "dev": "deno run --watch main.ts"
-  },
-  "imports": {
-    "@faker-js/faker": "npm:@faker-js/faker@^9.4.0",
-    "@std/assert": "jsr:@std/assert@1"
-  },
-  "lint": {
-    "rules": {
-      "exclude": [
-        "prefer-const",
-        "no-unused-vars",
-        "no-explicit-any",
-        "ban-types"
-      ]
-    }
-  }
+	"name": "@functions/mock",
+	"description": "Lightweight utility to generate realistic mock data for tests fast.",
+	"version": "1.1.1",
+	"license": "MIT",
+	"exports": "./mod.ts",
+	"tasks": {
+		"dev": "deno run --watch main.ts"
+	},
+	"imports": {
+		"@faker-js/faker": "npm:@faker-js/faker@^9.4.0",
+		"@std/assert": "jsr:@std/assert@1"
+	},
+	"lint": {
+		"rules": {
+			"exclude": [
+				"prefer-const",
+				"no-unused-vars",
+				"no-explicit-any",
+				"ban-types"
+			]
+		}
+	},
+	"fmt": {
+		"useTabs": true,
+		"lineWidth": 125,
+		"semiColons": false,
+		"singleQuote": true,
+		"proseWrap": "preserve"
+	}
 }

main_test.ts

@@ -1,22 +1,21 @@
-import { assertEquals, assertExists, assertGreater, assertInstanceOf, assertLess } from "@std/assert";
+import { assertEquals, assertExists, assertGreater, assertInstanceOf, assertLess } from '@std/assert'
 
-import { getMocksFromGenerator } from "./utils/get-mocks-from-gen.ts";
-import { getMocksWith } from "./utils/get-mocks-with.ts"
+import { getMocksFromGenerator } from './utils/get-mocks-from-gen.ts'
+import { getMocksWith } from './utils/get-mocks-with.ts'
 import { faker } from '@faker-js/faker'
 
-
-Deno.test("Get Mocks from custom generator", () => {
-
+Deno.test('Get Mocks from custom generator', () => {
 	let generator = {
 		name: faker.person.firstName,
 		surname: faker.person.lastName,
 		bio: faker.person.bio,
 		email: faker.internet.email,
-		age: () => faker.helpers.rangeToNumber({min:18,max:99}),
-		birthday: faker.date.birthdate
+		age: (): number => Math.floor(Math.random() * (100 - 18 + 1)) + 18,
+		// age: () => faker.helpers.rangeToNumber({ min: 18, max: 99 }),
+		birthday: faker.date.birthdate,
 	}
 
-	let generateUser = getMocksFromGenerator( generator )
+	let generateUser = getMocksFromGenerator(generator)
 	let user = generateUser(1)
 
 	assertInstanceOf(user, Array)
@@ -25,18 +24,18 @@ Deno.test("Get Mocks from custom generator", () => {
 
 	assertExists(user[0].age)
 	assertGreater(user[0].age, 17)
-});
+})
 
-Deno.test("Get Mocks from specific list", () => {
-	let generateUser = getMocksWith(['name','email','birthdate','id', 'age'])
+Deno.test('Get Mocks from specific list', () => {
+	let generateUser = getMocksWith(['name', 'email', 'birthdate', 'id', 'age'])
 	let user = generateUser(1)[0]
 	// user has 5 props
-	assertEquals(Object.keys(user).length, 5 )
+	assertEquals(Object.keys(user).length, 5)
 
 	// age is a number
 	assertGreater(user.age, 17)
-	assertLess(user.age,100)
-	
+	assertLess(user.age, 100)
+
 	// birthday is a Date
 	assertInstanceOf(user.birthdate, Date)
 })

mod.ts

@@ -1,2 +1,2 @@
-export { getMocksFromGenerator } from "./utils/get-mocks-from-gen.ts";
-export { getMocksWith } from "./utils/get-mocks-with.ts";
+export { getMocksFromGenerator } from './utils/get-mocks-from-gen.ts'
+export { getMocksWith } from './utils/get-mocks-with.ts'

utils/get-mocks-from-gen.ts

@@ -1,20 +1,21 @@
-
-type MockType = <T extends Record<string,() => any> >(gen: T) => ( num?: number) => Array<{ [K in keyof T]: ReturnType<T[K]> }>
+type TMock = <T extends Record<string, () => any>>(g: T) => (n?: number) => { [K in keyof T]: ReturnType<T[K]> }[]
 /**
- * Generate an array of random objects from your generator: 
+ * Generate an array of random objects from your generator:
  * Fake objects will have every key as a prop, its value will be the result of its callback
- * 
- * USAGE:  
- * import { faker } from '@faker-js/faker'  
- * const yourGenerator = { id: faker.number.int, name: faker.string.firstName, age: Math.random // TODO }  
- * const yourObjects = getMocksFromGenerator(yourGenerator, 5)  
-*/
-export const getMocksFromGenerator: MockType = gen => ( num = 1 ) => {
-
-	const genRandomObj = () => Object.entries(gen).reduce((obj, [prop, callback]) => {
-		obj[prop] = callback()
-		return obj 
-	}, Object.create(null))
+ *
+ * @example Basic Usage:
+ * ```ts
+ * import { faker } from '@faker-js/faker'
+ * const yourGenerator = { name: faker.string.firstName, age: () => Math.floor(Math.random() * 100 ) }
+ * const yourObjects = getMocksFromGenerator(yourGenerator, 5)
+ * ```
+ */
+export const getMocksFromGenerator: TMock = (gen) => (num = 1) => {
+	const genRandomObj = () =>
+		Object.entries(gen).reduce((obj, [prop, callback]) => {
+			obj[prop] = callback()
+			return obj
+		}, Object.create(null))
 
 	return Array.from({ length: num }, genRandomObj)
 }

utils/get-mocks-with.ts

@@ -1,46 +1,43 @@
 import { faker } from '@faker-js/faker'
-import { getMocksFromGenerator } from "./get-mocks-from-gen.ts"
+import { getMocksFromGenerator } from './get-mocks-from-gen.ts'
 
 const uniGenerator = {
-  id: faker.string.uuid,
-  owner_id: faker.string.uuid,
-  name: faker.person.firstName,
-  age: (): number => faker.number.int({ min: 18, max: 99 }),
-  username: faker.internet.username,
-  email: faker.internet.email,
-  avatar: faker.image.avatar,
-  password: faker.internet.password,
-  birthdate: faker.date.birthdate,
-  registeredAt: faker.date.past,
-  last_modified: faker.date.recent,
-  timestamp: faker.date.past,
+	id: faker.string.uuid,
+	owner_id: faker.string.uuid,
+	name: faker.person.firstName,
+	age: (): number => faker.number.int({ min: 18, max: 99 }),
+	username: faker.internet.username,
+	email: faker.internet.email,
+	avatar: faker.image.avatar,
+	password: faker.internet.password,
+	birthdate: faker.date.birthdate,
+	registeredAt: faker.date.past,
+	last_modified: faker.date.recent,
+	timestamp: faker.date.past,
 }
 
 type Generator = typeof uniGenerator
 type GenKeys = keyof Generator
-type GetGenCallableFn = <T extends GenKeys>( props: Array<T> ) => {[K in T]: Generator[K]}
-
+type GetGenCallableFn = <T extends GenKeys>(props: Array<T>) => { [K in T]: Generator[K] }
 
 const getGenerator: GetGenCallableFn = (props) => {
-	return props.reduce((acc,curr) => ({...acc, [curr]:uniGenerator[curr]}), Object.create(null) )
+	return props.reduce((acc, curr) => ({ ...acc, [curr]: uniGenerator[curr] }), Object.create(null))
 }
 
-type GetMocksCallableFn = <T extends GenKeys>(props: Array<T>) => (num:number) => Array<{[K in T]: ReturnType<Generator[K]>}>
+type GetMocksCallableFn = <T extends GenKeys>(p: T[]) => (n: number) => Array<{ [K in T]: ReturnType<Generator[K]> }>
 /**
  * Generate the random function to create your mock object/s based on a list of properties
- * It preserves type safety and autocompletion
- *  
- * Usage:  
- * const props = ['name', 'age', 'email']  
- * const createRandomUsers = generateMocksFrom(props)  
- * console.log( createRandomUsers(3) )
+ * It preserves type safety and autocompletion.
+ *
+ * @example Basic Usage:
+ * ```ts
+ * const props = ['name', 'age', 'email']
+ * const createRandomUsers = generateMocksFrom(props)
+ * console.log( createRandomUsers(3) ) // [{name:string, age:number, email: string}, ...]
+ * ```
  */
 export const getMocksWith: GetMocksCallableFn = (properties) => getMocksFromGenerator(getGenerator(properties))
 
-
-
-
-
 /* OLD Implementation with Map
 // @ts-ignore
 const generator = new Map([
@@ -66,4 +63,3 @@ const createGenerator = <T extends GenKeys>(properties: Array<T> ): {[K in T]:ty
 }
 
 export const getMocksWith = (props: Array<GenKeys>) => getMocksFromGenerator( createGenerator(props) ) */
-