feat: 🔥 First punt at priority option

packages/falso/src/lib/address.ts

@@ -64,5 +64,10 @@ export function randAddress<Options extends AddressOptions = never>(
     return address;
   };
 
-  return fake(factory, options);
+  return fake(factory, options, checkUnique);
 }
+
+const checkUnique: (item: Address, items: Address[]) => boolean = (
+  item: Address,
+  items: Address[]
+) => items.some((i) => i.street + i.zipCode === item.street + item.zipCode);

packages/falso/src/lib/between-date.ts

@@ -1,4 +1,4 @@
-import { fake, FakeOptions } from './core/core';
+import { checkUniqueDate, fake, FakeOptions } from './core/core';
 import { randNumber } from './number';
 
 interface BetweenOptions extends FakeOptions {
@@ -39,5 +39,5 @@ export function randBetweenDate<Options extends BetweenOptions = never>(
     );
   };
 
-  return fake(generator, options);
+  return fake(generator, options, checkUniqueDate);
 }

packages/falso/src/lib/core/core.ts

@@ -2,6 +2,7 @@ import { random } from '../random';
 
 export interface FakeOptions {
   length?: number;
+  priority?: 'length' | 'unique';
 }
 
 type Return<T, O extends FakeOptions> = [O] extends [never]
@@ -11,21 +12,94 @@ type Return<T, O extends FakeOptions> = [O] extends [never]
   : T;
 
 export function fake<T, Options extends FakeOptions>(
-  data: T[] | ((i: number) => T),
-  options?: Options
+  data: T[] | (() => T),
+  options?: Options,
+  comparisonFunction: (item: T, items: T[]) => boolean = checkUniquePrimitive
 ): Return<T, Options> {
-  const dataSource = Array.isArray(data) ? () => randElement(data) : data;
+  if (Array.isArray(data)) {
+    return fakeFromArray(data, options) as any;
+  }
+
+  return fakeFromFunction(data, comparisonFunction, options) as any;
+}
+
+export function fakeFromFunction<T, Options extends FakeOptions>(
+  data: () => T,
+  comparisonFunction: (item: T, items: T[]) => boolean,
+  options?: Options
+) {
+  if (!options?.length) {
+    return data();
+  }
+
+  const priority = options?.priority ?? 'length';
+
+  if (priority === 'length') {
+    return Array.from({ length: options.length }, (_, index) => data());
+  }
+
+  const items: T[] = [];
+
+  let attempts = 0;
+  const maxAttempts = options.length * 2;
+
+  while (items.length < options.length && attempts < maxAttempts) {
+    const item = data();
+
+    if (!comparisonFunction(item, items)) {
+      items.push(item);
+    }
 
+    attempts++;
+  }
+
+  return items;
+}
+
+export function fakeFromArray<T, Options extends FakeOptions>(
+  data: T[],
+  options?: Options
+) {
   if (!options?.length) {
-    return dataSource(0) as any;
+    return randElement(data);
+  }
+
+  const priority = options?.priority ?? 'length';
+
+  if (priority === 'length') {
+    return Array.from({ length: options.length }, () => randElement(data));
   }
 
-  return Array.from({ length: options.length }, (_, index) =>
-    dataSource(index)
-  ) as any;
+  const clonedData: T[] = JSON.parse(JSON.stringify(data));
+  const newArray: T[] = [];
+
+  while (clonedData.length && newArray.length !== options.length) {
+    const randomIndex = Math.floor(random() * clonedData.length);
+    const item = clonedData[randomIndex];
+
+    newArray.push(item);
+    clonedData.splice(randomIndex, 1);
+  }
+
+  return newArray;
 }
 
-export function randElement<T>(arr: T[]) {
+export const checkUniquePrimitive: <T>(item: T, items: T[]) => boolean = (
+  item,
+  items
+) => items.includes(item);
+
+export const checkUniqueDate: (date: Date, dates: Date[]) => boolean = (
+  date,
+  dates
+) => dates.some((d) => d.valueOf() === date.valueOf());
+
+export const checkUniqueObjectWithId: <T extends { id: string }>(
+  item: T,
+  items: T[]
+) => boolean = (item, items) => items.some((i) => i.id === item.id);
+
+export function randElement<T>(arr: T[]): T {
   return arr[Math.floor(random() * arr.length)];
 }
 

packages/falso/src/lib/credit-card.ts

@@ -81,5 +81,10 @@ export function randCreditCard<Options extends CreditCardOptions = never>(
     };
   };
 
-  return fake(factory, options);
+  return fake(factory, options, checkUnique);
 }
+
+const checkUnique: (card: CreditCard, cards: CreditCard[]) => boolean = (
+  card,
+  cards
+) => cards.some((c) => c.number === card.number);

packages/falso/src/lib/flight-details.ts

@@ -5,6 +5,7 @@ import { Airline, randFlightNumber } from './flight-number';
 import { randFullName } from './full-name';
 import { randSeatNumber } from './seat-number';
 import { Airport, randAirport } from './airport';
+import { CreditCard } from './credit-card';
 
 export interface FlightDetailsOptions extends FakeOptions {
   airline?: Airline;
@@ -71,5 +72,15 @@ export function randFlightDetails<Options extends FlightDetailsOptions = never>(
     };
   };
 
-  return fake(factory, options);
+  return fake(factory, options, checkUnique);
 }
+
+const checkUnique: (
+  flight: FlightDetails,
+  flights: FlightDetails[]
+) => boolean = (flight, flights) =>
+  flights.some(
+    (f) =>
+      f.passenger + f.flightNumber + f.date ===
+      flight.passenger + flight.flightNumber + flight.date
+  );

packages/falso/src/lib/float.ts

@@ -37,5 +37,3 @@ export function randFloat<Options extends RandomFloatOptions = never>(
   };
   return fake(() => getRandomInRange(o), options);
 }
-
-randFloat();

packages/falso/src/lib/full-address.ts

@@ -1,4 +1,4 @@
-import { FakeOptions, fake } from './core/core';
+import { fake } from './core/core';
 import { AddressOptions, randAddress } from './address';
 
 /**
@@ -29,7 +29,7 @@ export function randFullAddress<Options extends AddressOptions = never>(
   const includeCounty: boolean = options?.includeCounty ?? true;
   const includeCountry: boolean = options?.includeCountry ?? true;
 
-  const factory = () => {
+  const factory: () => string = () => {
     const { street, city, county, country, zipCode } = randAddress({
       includeCounty,
       includeCountry,

packages/falso/src/lib/future-date.ts

@@ -1,5 +1,5 @@
 import { randBetweenDate } from './between-date';
-import { fake, FakeOptions } from './core/core';
+import { checkUniqueDate, fake, FakeOptions } from './core/core';
 
 interface FutureOptions extends FakeOptions {
   years?: number;
@@ -35,5 +35,7 @@ export function randFutureDate<Options extends FutureOptions = never>(
   const yearsInMilliseconds = years * 365 * 24 * 60 * 60 * 1000;
   const from = new Date();
   const to = new Date(from.getTime() + yearsInMilliseconds);
-  return fake(() => randBetweenDate({ from, to }), options);
+  const factory: () => Date = () => randBetweenDate({ from, to });
+
+  return fake(factory, options, checkUniqueDate);
 }

packages/falso/src/lib/json.ts

@@ -88,5 +88,10 @@ export function randJSON<Options extends RandomJSONOptions = never>(
     return generatedObject;
   };
 
-  return fake(factory, options);
+  return fake(factory, options, checkUnique);
 }
+
+const checkUnique: (item: object, items: object[]) => boolean = (
+  item: object,
+  items: object[]
+) => items.some((i) => JSON.stringify(i) === JSON.stringify(item));

packages/falso/src/lib/nearby-gpscoordinate.ts

@@ -19,5 +19,9 @@ import { randLongitude } from './longitude';
 export function randNearbyGPSCoordinate<Options extends FakeOptions = never>(
   options?: Options
 ) {
-  return fake(() => [randLatitude(), randLongitude()], options);
+  return fake(() => [randLatitude(), randLongitude()], options, checkUnique);
 }
+
+const checkUnique: (coordinate: number[], coordinates: number[][]) => boolean =
+  (coordinate, coordinates) =>
+    coordinates.some((c) => c.join('') === c.join(''));

packages/falso/src/lib/past-date.ts

@@ -1,5 +1,5 @@
 import { randBetweenDate } from './between-date';
-import { fake, FakeOptions } from './core/core';
+import { checkUniqueDate, fake, FakeOptions } from './core/core';
 
 interface PastOptions extends FakeOptions {
   years?: number;
@@ -36,5 +36,5 @@ export function randPastDate<Options extends PastOptions = never>(
   const to = new Date();
   const from = new Date(to.getTime() - yearsInMilliseconds);
 
-  return fake(() => randBetweenDate({ from, to }), options);
+  return fake(() => randBetweenDate({ from, to }), options, checkUniqueDate);
 }

packages/falso/src/lib/post.ts

@@ -1,4 +1,4 @@
-import { FakeOptions, fake } from './core/core';
+import { FakeOptions, fake, checkUniqueObjectWithId } from './core/core';
 import { randUser, User } from './user';
 import { randUuid } from './uuid';
 import { randText } from './text';
@@ -28,7 +28,7 @@ export interface Post {
 export function randPost<Options extends FakeOptions = never>(
   options?: Options
 ) {
-  return fake(() => {
+  const factory = () => {
     const post: Post = {
       id: randUuid(),
       title: randText({ charCount: 40 }),
@@ -43,5 +43,7 @@ export function randPost<Options extends FakeOptions = never>(
     };
 
     return post;
-  }, options);
+  };
+
+  return fake(factory, options, checkUniqueObjectWithId);
 }

packages/falso/src/lib/product.ts

@@ -1,4 +1,9 @@
-import { FakeOptions, fake, getRandomInRange } from './core/core';
+import {
+  FakeOptions,
+  fake,
+  getRandomInRange,
+  checkUniqueObjectWithId,
+} from './core/core';
 import { randUuid } from './uuid';
 import { randProductName } from './product-name';
 import { randProductDescription } from './product-description';
@@ -35,19 +40,18 @@ export interface Product {
 export function randProduct<Options extends FakeOptions = never>(
   options?: Options
 ) {
-  return fake(
-    () => ({
-      id: randUuid(),
-      title: randProductName(),
-      description: randProductDescription(),
-      price: getRandomInRange({ fraction: 2 }).toString(),
-      category: randProductCategory(),
-      image: randImg(),
-      rating: {
-        rate: getRandomInRange({ min: 0.1, max: 5.0, fraction: 1 }).toString(),
-        count: getRandomInRange({ min: 0, max: 10000 }).toString(),
-      },
-    }),
-    options
-  );
+  const factory = () => ({
+    id: randUuid(),
+    title: randProductName(),
+    description: randProductDescription(),
+    price: getRandomInRange({ fraction: 2 }).toString(),
+    category: randProductCategory(),
+    image: randImg(),
+    rating: {
+      rate: getRandomInRange({ min: 0.1, max: 5.0, fraction: 1 }).toString(),
+      count: getRandomInRange({ min: 0, max: 10000 }).toString(),
+    },
+  });
+
+  return fake(factory, options, checkUniqueObjectWithId);
 }

packages/falso/src/lib/recent-date.ts

@@ -1,5 +1,5 @@
 import { randBetweenDate } from './between-date';
-import { fake, FakeOptions } from './core/core';
+import { checkUniqueDate, fake, FakeOptions } from './core/core';
 
 interface RecentOptions extends FakeOptions {
   days?: number;
@@ -36,5 +36,5 @@ export function randRecentDate<Options extends RecentOptions = never>(
   const to = new Date();
   const from = new Date(to.getTime() - daysInMilliseconds);
 
-  return fake(() => randBetweenDate({ from, to }), options);
+  return fake(() => randBetweenDate({ from, to }), options, checkUniqueDate);
 }

packages/falso/src/lib/soon-date.ts

@@ -1,5 +1,5 @@
 import { randBetweenDate } from './between-date';
-import { fake, FakeOptions } from './core/core';
+import { checkUniqueDate, fake, FakeOptions } from './core/core';
 
 interface SoonOptions extends FakeOptions {
   days?: number;
@@ -35,5 +35,5 @@ export function randSoonDate<Options extends SoonOptions = never>(
   const daysInMilliseconds = days * 24 * 60 * 60 * 1000;
   const from = new Date();
   const to = new Date(from.getTime() + daysInMilliseconds);
-  return fake(() => randBetweenDate({ from, to }), options);
+  return fake(() => randBetweenDate({ from, to }), options, checkUniqueDate);
 }

packages/falso/src/lib/superhero.ts

@@ -1,4 +1,9 @@
-import { fake, FakeOptions, randElement } from './core/core';
+import {
+  fake,
+  FakeOptions,
+  checkUniqueObjectWithId,
+  randElement,
+} from './core/core';
 import { data } from './superhero.json';
 import { randUuid } from './uuid';
 
@@ -50,5 +55,5 @@ export function randSuperhero<Options extends SuperheroOptions = never>(
     };
   };
 
-  return fake(factory, options);
+  return fake(factory, options, checkUniqueObjectWithId);
 }

packages/falso/src/lib/todo.ts

@@ -1,4 +1,4 @@
-import { fake, FakeOptions } from './core/core';
+import { fake, FakeOptions, checkUniqueObjectWithId } from './core/core';
 import { randUuid } from './uuid';
 import { randBoolean } from './boolean';
 import { randText } from './text';
@@ -26,11 +26,11 @@ export interface Todo {
 export function randTodo<Options extends FakeOptions = never>(
   options?: Options
 ) {
-  return fake(() => {
-    return {
-      id: randUuid(),
-      title: randText({ charCount: 40 }),
-      completed: randBoolean(),
-    } as Todo;
-  }, options);
+  const factory: () => Todo = () => ({
+    id: randUuid(),
+    title: randText({ charCount: 40 }),
+    completed: randBoolean(),
+  });
+
+  return fake(factory, options, checkUniqueObjectWithId);
 }