@prismicio/mock 0.0.8 → 0.1.0

package/src/value/createValueMockFactory.ts

@@ -0,0 +1,236 @@
+import * as prismicT from "@prismicio/types";
+
+import { createFaker, Faker } from "../lib/createFaker";
+
+import { Seed, WithoutFakerConfig } from "../types";
+
+import { boolean, MockBooleanValueConfig } from "./boolean";
+import { color, MockColorValueConfig } from "./color";
+import {
+	contentRelationship,
+	MockContentRelationshipValueConfig,
+} from "./contentRelationship";
+import { customType, MockCustomTypeValueConfig } from "./customType";
+import { date, MockDateValueConfig } from "./date";
+import { document, MockDocumentValueConfig } from "./document";
+import { embed, MockEmbedValueConfig } from "./embed";
+import { geoPoint, MockGeoPointValueConfig } from "./geoPoint";
+import { group, MockGroupValueConfig } from "./group";
+import { image, MockImageValueConfig } from "./image";
+import {
+	integrationFields,
+	MockIntegrationFieldsValueConfig,
+} from "./integrationFields";
+import { keyText, MockKeyTextValueConfig } from "./keyText";
+import { link, MockLinkValueConfig } from "./link";
+import { linkToMedia, MockLinkToMediaValueConfig } from "./linkToMedia";
+import { number, MockNumberValueConfig } from "./number";
+import { richText, MockRichTextValueConfig } from "./richText";
+import { select, MockSelectValueConfig } from "./select";
+import { sharedSlice, MockSharedSliceValueConfig } from "./sharedSlice";
+import {
+	sharedSliceVariation,
+	MockSharedSliceVariationValueConfig,
+} from "./sharedSliceVariation";
+import { slice, MockSliceValueConfig } from "./slice";
+import { sliceZone, MockSliceZoneValueConfig } from "./sliceZone";
+import { timestamp, MockTimestampValueConfig } from "./timestamp";
+import { title, MockTitleValueConfig } from "./title";
+import { uid, MockUIDValueConfig } from "./uid";
+
+export const createValueMockFactory = (
+	...args: ConstructorParameters<typeof ValueMockFactory>
+): ValueMockFactory => {
+	return new ValueMockFactory(...args);
+};
+
+type ValueMockFactoryConfig =
+	| {
+			seed: Seed;
+	  }
+	| {
+			faker: Faker;
+	  };
+
+export class ValueMockFactory {
+	private faker: Faker;
+
+	constructor(config: ValueMockFactoryConfig) {
+		this.faker = "faker" in config ? config.faker : createFaker(config.seed);
+	}
+
+	get seed() {
+		return this.faker.seed;
+	}
+
+	boolean<Model extends prismicT.CustomTypeModelBooleanField>(
+		config?: WithoutFakerConfig<MockBooleanValueConfig<Model>>,
+	) {
+		return boolean({ ...config, faker: this.faker });
+	}
+
+	color<
+		Model extends prismicT.CustomTypeModelColorField = prismicT.CustomTypeModelColorField,
+		State extends prismicT.FieldState = "filled",
+	>(config?: WithoutFakerConfig<MockColorValueConfig<Model, State>>) {
+		return color({ ...config, faker: this.faker });
+	}
+
+	contentRelationship<
+		Model extends prismicT.CustomTypeModelContentRelationshipField = prismicT.CustomTypeModelContentRelationshipField,
+		State extends prismicT.FieldState = "filled",
+	>(
+		config?: WithoutFakerConfig<
+			MockContentRelationshipValueConfig<Model, State>
+		>,
+	) {
+		return contentRelationship({ ...config, faker: this.faker });
+	}
+
+	customType<Model extends prismicT.CustomTypeModel = prismicT.CustomTypeModel>(
+		config?: WithoutFakerConfig<MockCustomTypeValueConfig<Model>>,
+	) {
+		return customType({ ...config, faker: this.faker });
+	}
+
+	date<
+		Model extends prismicT.CustomTypeModelDateField = prismicT.CustomTypeModelDateField,
+		State extends prismicT.FieldState = "filled",
+	>(config?: WithoutFakerConfig<MockDateValueConfig<Model, State>>) {
+		return date({ ...config, faker: this.faker });
+	}
+
+	document<Model extends prismicT.CustomTypeModel = prismicT.CustomTypeModel>(
+		config?: WithoutFakerConfig<MockDocumentValueConfig<Model>>,
+	) {
+		return document({ ...config, faker: this.faker });
+	}
+
+	embed<
+		Model extends prismicT.CustomTypeModelEmbedField = prismicT.CustomTypeModelEmbedField,
+		Data extends prismicT.AnyOEmbed = prismicT.AnyOEmbed,
+		State extends prismicT.FieldState = "filled",
+	>(config?: WithoutFakerConfig<MockEmbedValueConfig<Model, Data, State>>) {
+		return embed({ ...config, faker: this.faker });
+	}
+
+	geoPoint<
+		Model extends prismicT.CustomTypeModelGeoPointField = prismicT.CustomTypeModelGeoPointField,
+		State extends prismicT.FieldState = "filled",
+	>(config?: WithoutFakerConfig<MockGeoPointValueConfig<Model, State>>) {
+		return geoPoint({ ...config, faker: this.faker });
+	}
+
+	group<
+		Model extends prismicT.CustomTypeModelGroupField = prismicT.CustomTypeModelGroupField,
+		State extends prismicT.FieldState = "filled",
+	>(config?: WithoutFakerConfig<MockGroupValueConfig<Model, State>>) {
+		return group({ ...config, faker: this.faker });
+	}
+
+	image<
+		Model extends prismicT.CustomTypeModelImageField = prismicT.CustomTypeModelImageField,
+		State extends prismicT.FieldState = "filled",
+	>(config?: WithoutFakerConfig<MockImageValueConfig<Model, State>>) {
+		return image({ ...config, faker: this.faker });
+	}
+
+	integrationFields<
+		Model extends prismicT.CustomTypeModelIntegrationFieldsField = prismicT.CustomTypeModelIntegrationFieldsField,
+		Data extends Record<string, unknown> = Record<string, unknown>,
+		State extends prismicT.FieldState = "filled",
+	>(
+		config?: WithoutFakerConfig<
+			MockIntegrationFieldsValueConfig<Model, Data, State>
+		>,
+	) {
+		return integrationFields({ ...config, faker: this.faker });
+	}
+
+	keyText<
+		Model extends prismicT.CustomTypeModelKeyTextField = prismicT.CustomTypeModelKeyTextField,
+		State extends prismicT.FieldState = "filled",
+	>(config?: WithoutFakerConfig<MockKeyTextValueConfig<Model, State>>) {
+		return keyText({ ...config, faker: this.faker });
+	}
+
+	link<
+		LinkType extends typeof prismicT.LinkType[keyof typeof prismicT.LinkType] = typeof prismicT.LinkType[keyof typeof prismicT.LinkType],
+		Model extends prismicT.CustomTypeModelLinkField = prismicT.CustomTypeModelLinkField,
+		State extends prismicT.FieldState = "filled",
+	>(config?: WithoutFakerConfig<MockLinkValueConfig<LinkType, Model, State>>) {
+		return link({ ...config, faker: this.faker });
+	}
+
+	linkToMedia<
+		Model extends prismicT.CustomTypeModelLinkToMediaField = prismicT.CustomTypeModelLinkToMediaField,
+		State extends prismicT.FieldState = "filled",
+	>(config?: WithoutFakerConfig<MockLinkToMediaValueConfig<Model, State>>) {
+		return linkToMedia({ ...config, faker: this.faker });
+	}
+
+	number<
+		Model extends prismicT.CustomTypeModelNumberField = prismicT.CustomTypeModelNumberField,
+		State extends prismicT.FieldState = "filled",
+	>(config?: WithoutFakerConfig<MockNumberValueConfig<Model, State>>) {
+		return number({ ...config, faker: this.faker });
+	}
+
+	select<
+		Model extends prismicT.CustomTypeModelSelectField = prismicT.CustomTypeModelSelectField,
+		State extends prismicT.FieldState = "filled",
+	>(config?: WithoutFakerConfig<MockSelectValueConfig<Model, State>>) {
+		return select({ ...config, faker: this.faker });
+	}
+
+	sharedSlice<
+		Model extends prismicT.SharedSliceModel = prismicT.SharedSliceModel,
+	>(config?: WithoutFakerConfig<MockSharedSliceValueConfig<Model>>) {
+		return sharedSlice({ ...config, faker: this.faker });
+	}
+
+	sharedSliceVariation<
+		Model extends prismicT.SharedSliceModelVariation = prismicT.SharedSliceModelVariation,
+	>(config?: WithoutFakerConfig<MockSharedSliceVariationValueConfig<Model>>) {
+		return sharedSliceVariation({ ...config, faker: this.faker });
+	}
+
+	slice<
+		Model extends prismicT.CustomTypeModelSlice = prismicT.CustomTypeModelSlice,
+	>(config?: WithoutFakerConfig<MockSliceValueConfig<Model>>) {
+		return slice({ ...config, faker: this.faker });
+	}
+
+	sliceZone<
+		Model extends prismicT.CustomTypeModelSliceZoneField = prismicT.CustomTypeModelSliceZoneField,
+		State extends prismicT.FieldState = "filled",
+	>(config?: WithoutFakerConfig<MockSliceZoneValueConfig<Model, State>>) {
+		return sliceZone({ ...config, faker: this.faker });
+	}
+
+	timestamp<
+		Model extends prismicT.CustomTypeModelTimestampField = prismicT.CustomTypeModelTimestampField,
+		State extends prismicT.FieldState = "filled",
+	>(config?: WithoutFakerConfig<MockTimestampValueConfig<Model, State>>) {
+		return timestamp({ ...config, faker: this.faker });
+	}
+
+	title<
+		Model extends prismicT.CustomTypeModelTitleField = prismicT.CustomTypeModelTitleField,
+		State extends prismicT.FieldState = "filled",
+	>(config?: WithoutFakerConfig<MockTitleValueConfig<Model, State>>) {
+		return title({ ...config, faker: this.faker });
+	}
+
+	uid<
+		Model extends prismicT.CustomTypeModelUIDField = prismicT.CustomTypeModelUIDField,
+	>(config?: WithoutFakerConfig<MockUIDValueConfig<Model>>) {
+		return uid({ ...config, faker: this.faker });
+	}
+
+	richText<
+		Model extends prismicT.CustomTypeModelRichTextField = prismicT.CustomTypeModelRichTextField,
+	>(config?: WithoutFakerConfig<MockRichTextValueConfig<Model>>) {
+		return richText({ ...config, faker: this.faker });
+	}
+}

package/src/value/customType.ts

@@ -26,11 +26,11 @@ export type MockCustomTypeValueConfig<
 export const customType = <
 	Model extends prismicT.CustomTypeModel = prismicT.CustomTypeModel,
 >(
-	config: MockCustomTypeValueConfig<Model> = {},
+	config: MockCustomTypeValueConfig<Model>,
 ): ModelValue<Model> => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
-	const model = config.model || modelGen.customType({ seed: config.seed });
+	const model = config.model || modelGen.customType({ faker });
 
 	const fieldModelsMap = Object.assign(
 		{},
@@ -63,19 +63,19 @@ export const customType = <
 
 	return {
 		type: model.id,
-		id: faker.git.shortSha(),
-		uid: hasUID ? changeCase.snakeCase(faker.lorem.words(2)) : null,
-		url: withURL ? faker.internet.url() : null,
-		href: faker.internet.url(),
-		lang: faker.lorem.word(),
-		tags: generateTags({ seed: config.seed }),
+		id: faker.hash(7),
+		uid: hasUID ? changeCase.snakeCase(faker.words(faker.range(1, 3))) : null,
+		url: withURL ? faker.url() : null,
+		href: faker.url(),
+		lang: faker.word(),
+		tags: generateTags({ faker }),
 		slugs: [] as prismicT.PrismicDocument["slugs"],
 		linked_documents: [] as prismicT.PrismicDocument["linked_documents"],
 		alternate_languages: alternateLanguages,
-		first_publication_date: timestamp({ seed: config.seed }),
-		last_publication_date: timestamp({ seed: config.seed }),
+		first_publication_date: timestamp({ faker }),
+		last_publication_date: timestamp({ faker }),
 		data: valueForModelMap({
-			seed: config.seed,
+			faker,
 			map: dataFieldModelsMap,
 			configs: config.configs,
 		}),

package/src/value/date.ts

@@ -1,5 +1,7 @@
 import * as prismicT from "@prismicio/types";
 
+import { createFaker } from "../lib/createFaker";
+
 import { MockValueStateConfig, MockValueConfig } from "../types";
 
 import { MockTimestampValueConfig, timestamp } from "./timestamp";
@@ -19,13 +21,15 @@ export const date = <
 	Model extends prismicT.CustomTypeModelDateField = prismicT.CustomTypeModelDateField,
 	State extends prismicT.FieldState = "filled",
 >(
-	config: MockDateValueConfig<Model, State> = {},
+	config: MockDateValueConfig<Model, State>,
 ): MockDateValue<State> => {
+	const faker = config.faker || createFaker(config.seed);
+
 	return (
 		config.state === "empty"
 			? null
 			: timestamp({
-					seed: config.seed,
+					faker,
 					after: config.after,
 					before: config.before,
 					state: "filled",

package/src/value/embed.ts

@@ -1,30 +1,46 @@
 import * as prismicT from "@prismicio/types";
 
 import { buildEmbedField } from "../lib/buildEmbedField";
+import { createFaker } from "../lib/createFaker";
 import { getMockEmbedData } from "../lib/getMockEmbedData";
 
 import { MockValueStateConfig, MockValueConfig } from "../types";
 
 export type MockEmbedValueConfig<
 	Model extends prismicT.CustomTypeModelEmbedField = prismicT.CustomTypeModelEmbedField,
+	Data extends prismicT.AnyOEmbed = prismicT.AnyOEmbed,
 	State extends prismicT.FieldState = prismicT.FieldState,
-> = MockValueConfig<Model> & MockValueStateConfig<State>;
+> = {
+	url?: string;
+	html?: string;
+	data?: Data;
+} & MockValueConfig<Model> &
+	MockValueStateConfig<State>;
 
 export type MockEmbedValue<
+	Data extends prismicT.AnyOEmbed = prismicT.AnyOEmbed,
 	State extends prismicT.FieldState = prismicT.FieldState,
-> = prismicT.EmbedField<prismicT.AnyOEmbed & prismicT.OEmbedExtra, State>;
+> = prismicT.EmbedField<Data, State>;
 
 export const embed = <
 	Model extends prismicT.CustomTypeModelEmbedField = prismicT.CustomTypeModelEmbedField,
+	Data extends prismicT.AnyOEmbed = prismicT.AnyOEmbed,
 	State extends prismicT.FieldState = "filled",
 >(
-	config: MockEmbedValueConfig<Model, State> = {},
-): MockEmbedValue<State> => {
-	const embedData = getMockEmbedData({ seed: config.seed });
+	config: MockEmbedValueConfig<Model, Data, State>,
+): MockEmbedValue<Data, State> => {
+	const faker = config.faker || createFaker(config.seed);
+
+	const data = config.data ?? getMockEmbedData({ faker });
 
 	return (
 		config.state === "empty"
 			? {}
-			: buildEmbedField({ seed: config.seed, embedData })
-	) as MockEmbedValue<State>;
+			: buildEmbedField({
+					faker,
+					url: config.url ?? ("embed_url" in data ? data.embed_url : undefined),
+					html: config.html ?? ("html" in data ? data.html : undefined),
+					data,
+			  })
+	) as MockEmbedValue<Data, State>;
 };

package/src/value/geoPoint.ts

@@ -17,18 +17,16 @@ export const geoPoint = <
 	Model extends prismicT.CustomTypeModelGeoPointField = prismicT.CustomTypeModelGeoPointField,
 	State extends prismicT.FieldState = "filled",
 >(
-	config: MockGeoPointValueConfig<Model, State> = {},
+	config: MockGeoPointValueConfig<Model, State>,
 ): MockGeoPointValue<State> => {
-	const faker = createFaker(config.seed);
-
-	const coordinates = faker.address.nearbyGPSCoordinate();
+	const faker = config.faker || createFaker(config.seed);
 
 	return (
 		config.state === "empty"
 			? {}
 			: {
-					longitude: Number.parseFloat(coordinates[0]),
-					latitude: Number.parseFloat(coordinates[1]),
+					longitude: faker.rangeFloat(-180, 180),
+					latitude: faker.rangeFloat(-90, 90),
 			  }
 	) as MockGeoPointValue<State>;
 };

package/src/value/group.ts

@@ -27,28 +27,23 @@ export const group = <
 	Model extends prismicT.CustomTypeModelGroupField = prismicT.CustomTypeModelGroupField,
 	State extends prismicT.FieldState = "filled",
 >(
-	config: MockGroupValueConfig<Model, State> = {},
+	config: MockGroupValueConfig<Model, State>,
 ): ModelValue<Model, State> => {
 	if (config.state === "empty") {
 		return [] as ModelValue<Model, State>;
 	} else {
-		const faker = createFaker(config.seed);
+		const faker = config.faker || createFaker(config.seed);
 
-		const model = config.model || modelGen.group({ seed: config.seed });
+		const model = config.model || modelGen.group({ faker });
 
-		const itemsCount =
-			config.itemsCount ??
-			faker.datatype.number({
-				min: 1,
-				max: 6,
-			});
+		const itemsCount = config.itemsCount ?? faker.range(1, 6);
 
 		return Array(itemsCount)
 			.fill(undefined)
 			.map(() => {
 				return valueForModelMap({
-					seed: config.seed,
-					map: model.config.fields,
+					faker,
+					map: model.config?.fields || {},
 					configs: config.configs,
 				});
 			}) as ModelValue<Model, State>;

package/src/value/image.ts

@@ -1,6 +1,7 @@
 import * as prismicT from "@prismicio/types";
 
 import { buildImageFieldImage } from "../lib/buildImageFieldImage";
+import { createFaker } from "../lib/createFaker";
 import { getMockImageData } from "../lib/getMockImageData";
 
 import { MockValueStateConfig, MockValueConfig } from "../types";
@@ -15,36 +16,43 @@ export type MockImageValueConfig<
 export type MockImageValue<
 	Model extends prismicT.CustomTypeModelImageField = prismicT.CustomTypeModelImageField,
 	State extends prismicT.FieldState = prismicT.FieldState,
-> = prismicT.ImageField<Model["config"]["thumbnails"][number]["name"], State>;
+> = prismicT.ImageField<
+	NonNullable<NonNullable<Model["config"]>["thumbnails"]>[number]["name"],
+	State
+>;
 
 export const image = <
 	Model extends prismicT.CustomTypeModelImageField = prismicT.CustomTypeModelImageField,
 	State extends prismicT.FieldState = "filled",
 >(
-	config: MockImageValueConfig<Model, State> = {},
+	config: MockImageValueConfig<Model, State>,
 ): MockImageValue<Model, State> => {
-	const model = config.model || modelGen.image({ seed: config.seed });
-	const imageData = getMockImageData({ seed: config.seed });
+	const faker = config.faker || createFaker(config.seed);
+
+	const model = config.model || modelGen.image({ faker });
+	const imageData = getMockImageData({ faker });
 
 	const value = buildImageFieldImage({
-		seed: config.seed,
+		faker,
 		imageData,
-		constraint: model.config.constraint,
+		constraint: model.config?.constraint,
 		state: config.state,
 	}) as MockImageValue<Model, State>;
 
-	for (const thumbnail of model.config.thumbnails) {
-		// TODO: Resolve the following type error
-		// @ts-expect-error - Unsure how to fix this type mismatch
-		value[thumbnail.name as keyof typeof value] = buildImageFieldImage({
-			seed: config.seed,
-			imageData,
-			constraint: {
-				width: thumbnail.width,
-				height: thumbnail.height,
-			},
-			state: config.state,
-		});
+	if (model.config?.thumbnails) {
+		for (const thumbnail of model.config.thumbnails) {
+			// TODO: Resolve the following type error
+			// @ts-expect-error - Unsure how to fix this type mismatch
+			value[thumbnail.name as keyof typeof value] = buildImageFieldImage({
+				faker,
+				imageData,
+				constraint: {
+					width: thumbnail.width,
+					height: thumbnail.height,
+				},
+				state: config.state,
+			});
+		}
 	}
 
 	return value;

package/src/value/integrationFields.ts

@@ -1,46 +1,32 @@
 import * as prismicT from "@prismicio/types";
-import * as changeCase from "change-case";
-
-import { createFaker } from "../lib/createFaker";
-import { getMockImageData } from "../lib/getMockImageData";
 
 import { MockValueStateConfig, MockValueConfig } from "../types";
 
 export type MockIntegrationFieldsValueConfig<
 	Model extends prismicT.CustomTypeModelIntegrationFieldsField = prismicT.CustomTypeModelIntegrationFieldsField,
-	Blob = unknown,
+	Data extends Record<string, unknown> = Record<string, unknown>,
 	State extends prismicT.FieldState = prismicT.FieldState,
 > = {
-	data?: Blob;
+	data?: Data;
 } & MockValueConfig<Model> &
 	MockValueStateConfig<State>;
 
 export type MockIntegrationFieldsValue<
-	Blob = unknown,
+	Data extends Record<string, unknown> = Record<string, unknown>,
 	State extends prismicT.FieldState = prismicT.FieldState,
-> = prismicT.IntegrationFields<Blob, State>;
+> = prismicT.IntegrationFields<Data, State>;
 
 export const integrationFields = <
 	Model extends prismicT.CustomTypeModelIntegrationFieldsField = prismicT.CustomTypeModelIntegrationFieldsField,
-	Blob = unknown,
+	Data extends Record<string, unknown> = Record<string, unknown>,
 	State extends prismicT.FieldState = "filled",
 >(
-	config: MockIntegrationFieldsValueConfig<Model, Blob, State> = {},
-): MockIntegrationFieldsValue<Blob, State> => {
-	const faker = createFaker(config.seed);
-
-	const imageData = getMockImageData({ seed: config.seed });
+	config: MockIntegrationFieldsValueConfig<Model, Data, State>,
+): MockIntegrationFieldsValue<Data, State> => {
+	const data = config.data ?? {};
 
-	return (
-		config.state === "empty"
-			? null
-			: {
-					id: faker.git.shortSha(),
-					title: changeCase.capitalCase(faker.lorem.words(3)),
-					description: faker.lorem.sentence(),
-					image_url: imageData.url,
-					last_update: faker.date.past(20, new Date("2021-03-07")).getTime(),
-					blob: config.data as Blob,
-			  }
-	) as MockIntegrationFieldsValue<Blob, State>;
+	return (config.state === "empty" ? null : data) as MockIntegrationFieldsValue<
+		Data,
+		State
+	>;
 };

package/src/value/keyText.ts

@@ -18,13 +18,11 @@ export const keyText = <
 	Model extends prismicT.CustomTypeModelKeyTextField = prismicT.CustomTypeModelKeyTextField,
 	State extends prismicT.FieldState = "filled",
 >(
-	config: MockKeyTextValueConfig<Model, State> = {},
+	config: MockKeyTextValueConfig<Model, State>,
 ): MockKeyTextValue<State> => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
 	return (
-		config.state === "empty"
-			? null
-			: changeCase.sentenceCase(faker.lorem.words(3))
+		config.state === "empty" ? null : changeCase.sentenceCase(faker.words(3))
 	) as MockKeyTextValue<State>;
 };

package/src/value/link.ts

@@ -15,7 +15,9 @@ export type MockLinkValueConfig<
 	State extends prismicT.FieldState = prismicT.FieldState,
 > = {
 	type?: LinkType;
-	withTargetBlank?: Model["config"]["allowTargetBlank"] extends undefined
+	withTargetBlank?: NonNullable<
+		Model["config"]
+	>["allowTargetBlank"] extends undefined
 		? false
 		: boolean;
 	/**
@@ -45,13 +47,13 @@ export const link = <
 	Model extends prismicT.CustomTypeModelLinkField = prismicT.CustomTypeModelLinkField,
 	State extends prismicT.FieldState = "filled",
 >(
-	config: MockLinkValueConfig<LinkType, Model, State> = {},
+	config: MockLinkValueConfig<LinkType, Model, State>,
 ): MockLinkValue<LinkType, State> => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
 	const type =
 		config.type ||
-		faker.random.arrayElement([
+		faker.randomElement([
 			prismicT.LinkType.Web,
 			prismicT.LinkType.Document,
 			prismicT.LinkType.Media,
@@ -65,7 +67,7 @@ export const link = <
 		switch (type) {
 			case prismicT.LinkType.Document: {
 				return contentRelationship({
-					seed: config.seed,
+					faker,
 					state: config.state,
 					linkableDocuments: config.linkableDocuments,
 				}) as unknown as MockLinkValue<LinkType, State>;
@@ -73,21 +75,21 @@ export const link = <
 
 			case prismicT.LinkType.Media: {
 				return linkToMedia({
-					seed: config.seed,
+					faker,
 					state: config.state,
 				}) as MockLinkValue<LinkType, State>;
 			}
 
 			case prismicT.LinkType.Web:
 			default: {
-				const model = config.model || modelGen.link({ seed: config.seed });
+				const model = config.model || modelGen.link({ faker });
 
 				return {
 					link_type: prismicT.LinkType.Web,
-					url: faker.internet.url(),
+					url: faker.url(),
 					target:
 						config.withTargetBlank ??
-						(model.config.allowTargetBlank && faker.datatype.boolean())
+						(model.config?.allowTargetBlank && faker.boolean())
 							? "_blank"
 							: undefined,
 				} as MockLinkValue<LinkType, State>;

package/src/value/linkToMedia.ts

@@ -1,4 +1,5 @@
 import * as prismicT from "@prismicio/types";
+import * as changeCase from "change-case";
 
 import { createFaker } from "../lib/createFaker";
 
@@ -17,9 +18,9 @@ export const linkToMedia = <
 	Model extends prismicT.CustomTypeModelLinkToMediaField = prismicT.CustomTypeModelLinkToMediaField,
 	State extends prismicT.FieldState = "filled",
 >(
-	config: MockLinkToMediaValueConfig<Model, State> = {},
+	config: MockLinkToMediaValueConfig<Model, State>,
 ): MockLinkToMediaValue<State> => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
 	if (config.state === "empty") {
 		return {
@@ -28,12 +29,12 @@ export const linkToMedia = <
 	} else {
 		return {
 			link_type: prismicT.LinkType.Media,
-			name: faker.system.commonFileName(),
-			kind: faker.system.commonFileType(),
-			url: faker.internet.url(),
-			size: faker.datatype.number().toString(),
-			height: faker.datatype.number().toString(),
-			width: faker.datatype.number().toString(),
+			name: `${changeCase.snakeCase(faker.words(faker.range(1, 2)))}.example`,
+			kind: changeCase.snakeCase(faker.word()),
+			url: faker.url(),
+			size: faker.range(500, 3000).toString(),
+			height: faker.range(500, 3000).toString(),
+			width: faker.range(500, 3000).toString(),
 		} as MockLinkToMediaValue<State>;
 	}
 };