@prismicio/mock 0.0.6 → 0.0.9

package/src/value/date.ts

@@ -1,18 +1,34 @@
 import * as prismicT from "@prismicio/types";
 
-import { MockValueConfig } from "../types";
+import { MockValueStateConfig, MockValueConfig } from "../types";
 
 import { MockTimestampValueConfig, timestamp } from "./timestamp";
 
 export type MockDateValueConfig<
 	Model extends prismicT.CustomTypeModelDateField = prismicT.CustomTypeModelDateField,
-> = Pick<MockTimestampValueConfig, "after" | "before"> & MockValueConfig<Model>;
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = Pick<MockTimestampValueConfig, "after" | "before"> &
+	MockValueConfig<Model> &
+	MockValueStateConfig<State>;
 
-export const date = (config: MockDateValueConfig = {}): prismicT.DateField => {
-	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-	return timestamp({
-		seed: config.seed,
-		after: config.after,
-		before: config.before,
-	})!.split("T")[0];
+export type MockDateValue<
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = prismicT.DateField<State>;
+
+export const date = <
+	Model extends prismicT.CustomTypeModelDateField = prismicT.CustomTypeModelDateField,
+	State extends prismicT.FieldState = "filled",
+>(
+	config: MockDateValueConfig<Model, State> = {},
+): MockDateValue<State> => {
+	return (
+		config.state === "empty"
+			? null
+			: timestamp({
+					seed: config.seed,
+					after: config.after,
+					before: config.before,
+					state: "filled",
+			  }).split("T")[0]
+	) as MockDateValue<State>;
 };

package/src/value/embed.ts

@@ -3,16 +3,41 @@ import * as prismicT from "@prismicio/types";
 import { buildEmbedField } from "../lib/buildEmbedField";
 import { getMockEmbedData } from "../lib/getMockEmbedData";
 
-import { MockValueConfig } from "../types";
+import { MockValueStateConfig, MockValueConfig } from "../types";
 
 export type MockEmbedValueConfig<
 	Model extends prismicT.CustomTypeModelEmbedField = prismicT.CustomTypeModelEmbedField,
-> = MockValueConfig<Model>;
+	Data extends prismicT.AnyOEmbed = prismicT.AnyOEmbed,
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = {
+	url?: string;
+	html?: string;
+	data?: Data;
+} & MockValueConfig<Model> &
+	MockValueStateConfig<State>;
 
-export const embed = (
-	config: MockEmbedValueConfig = {},
-): prismicT.EmbedField => {
-	const embedData = getMockEmbedData({ seed: config.seed });
+export type MockEmbedValue<
+	Data extends prismicT.AnyOEmbed = prismicT.AnyOEmbed,
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = prismicT.EmbedField<Data, State>;
 
-	return buildEmbedField({ seed: config.seed, embedData });
+export const embed = <
+	Model extends prismicT.CustomTypeModelEmbedField = prismicT.CustomTypeModelEmbedField,
+	Data extends prismicT.AnyOEmbed = prismicT.AnyOEmbed,
+	State extends prismicT.FieldState = "filled",
+>(
+	config: MockEmbedValueConfig<Model, Data, State> = {},
+): MockEmbedValue<Data, State> => {
+	const data = config.data ?? getMockEmbedData({ seed: config.seed });
+
+	return (
+		config.state === "empty"
+			? {}
+			: buildEmbedField({
+					seed: config.seed,
+					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

@@ -2,21 +2,31 @@ import * as prismicT from "@prismicio/types";
 
 import { createFaker } from "../lib/createFaker";
 
-import { MockValueConfig } from "../types";
+import { MockValueStateConfig, MockValueConfig } from "../types";
 
 export type MockGeoPointValueConfig<
 	Model extends prismicT.CustomTypeModelGeoPointField = prismicT.CustomTypeModelGeoPointField,
-> = MockValueConfig<Model>;
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = MockValueConfig<Model> & MockValueStateConfig<State>;
 
-export const geoPoint = (
-	config: MockGeoPointValueConfig = {},
-): prismicT.GeoPointField => {
-	const faker = createFaker(config.seed);
+export type MockGeoPointValue<
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = prismicT.GeoPointField<State>;
 
-	const coordinates = faker.address.nearbyGPSCoordinate();
+export const geoPoint = <
+	Model extends prismicT.CustomTypeModelGeoPointField = prismicT.CustomTypeModelGeoPointField,
+	State extends prismicT.FieldState = "filled",
+>(
+	config: MockGeoPointValueConfig<Model, State> = {},
+): MockGeoPointValue<State> => {
+	const faker = createFaker(config.seed);
 
-	return {
-		longitude: Number.parseFloat(coordinates[0]),
-		latitude: Number.parseFloat(coordinates[1]),
-	};
+	return (
+		config.state === "empty"
+			? {}
+			: {
+					longitude: faker.rangeFloat(-180, 180),
+					latitude: faker.rangeFloat(-90, 90),
+			  }
+	) as MockGeoPointValue<State>;
 };

package/src/value/group.ts

@@ -6,60 +6,46 @@ import {
 	ValueForModelMapConfigs,
 } from "../lib/valueForModelMap";
 
-import { MockValueConfig, ModelValue } from "../types";
+import { MockValueConfig, MockValueStateConfig, ModelValue } from "../types";
 
 import * as modelGen from "../model";
 
-const patterns = {
-	short: {
-		minItems: 1,
-		maxItems: 3,
-	},
-	medium: {
-		minItems: 3,
-		maxItems: 6,
-	},
-	long: {
-		minItems: 6,
-		maxItems: 12,
-	},
-} as const;
-
 export type MockGroupValueConfig<
 	Model extends prismicT.CustomTypeModelGroupField = prismicT.CustomTypeModelGroupField,
+	State extends prismicT.FieldState = prismicT.FieldState,
 > = {
-	pattern?: keyof typeof patterns;
+	itemsCount?: State extends "empty" ? 0 : number;
 	configs?: ValueForModelMapConfigs;
-} & MockValueConfig<Model>;
+} & MockValueConfig<Model> &
+	MockValueStateConfig<State>;
+
+export type MockGroupValue<
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = prismicT.DateField<State>;
 
 export const group = <
 	Model extends prismicT.CustomTypeModelGroupField = prismicT.CustomTypeModelGroupField,
+	State extends prismicT.FieldState = "filled",
 >(
-	config: MockGroupValueConfig<Model> = {},
-): ModelValue<Model> => {
-	const faker = createFaker(config.seed);
-
-	const model = config.model || modelGen.group({ seed: config.seed });
-
-	const patternKey =
-		config.pattern ||
-		faker.random.arrayElement(
-			Object.keys(patterns) as (keyof typeof patterns)[],
-		);
-	const pattern = patterns[patternKey];
-
-	const itemsCount = faker.datatype.number({
-		min: pattern.minItems,
-		max: pattern.maxItems,
-	});
-
-	return Array(itemsCount)
-		.fill(undefined)
-		.map(() => {
-			return valueForModelMap({
-				seed: config.seed,
-				map: model.config.fields,
-				configs: config.configs,
-			});
-		}) as ModelValue<Model>;
+	config: MockGroupValueConfig<Model, State> = {},
+): ModelValue<Model, State> => {
+	if (config.state === "empty") {
+		return [] as ModelValue<Model, State>;
+	} else {
+		const faker = createFaker(config.seed);
+
+		const model = config.model || modelGen.group({ seed: config.seed });
+
+		const itemsCount = config.itemsCount ?? faker.range(1, 6);
+
+		return Array(itemsCount)
+			.fill(undefined)
+			.map(() => {
+				return valueForModelMap({
+					seed: config.seed,
+					map: model.config.fields,
+					configs: config.configs,
+				});
+			}) as ModelValue<Model, State>;
+	}
 };

package/src/value/image.ts

@@ -1,36 +1,49 @@
 import * as prismicT from "@prismicio/types";
 
-import { buildImageField } from "../lib/buildImageField";
+import { buildImageFieldImage } from "../lib/buildImageFieldImage";
 import { getMockImageData } from "../lib/getMockImageData";
 
-import { MockValueConfig } from "../types";
+import { MockValueStateConfig, MockValueConfig } from "../types";
 
 import * as modelGen from "../model";
 
 export type MockImageValueConfig<
 	Model extends prismicT.CustomTypeModelImageField = prismicT.CustomTypeModelImageField,
-> = MockValueConfig<Model>;
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = MockValueConfig<Model> & MockValueStateConfig<State>;
 
-export const image = (
-	config: MockImageValueConfig = {},
-): prismicT.ImageField => {
+export type MockImageValue<
+	Model extends prismicT.CustomTypeModelImageField = prismicT.CustomTypeModelImageField,
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = prismicT.ImageField<Model["config"]["thumbnails"][number]["name"], State>;
+
+export const image = <
+	Model extends prismicT.CustomTypeModelImageField = prismicT.CustomTypeModelImageField,
+	State extends prismicT.FieldState = "filled",
+>(
+	config: MockImageValueConfig<Model, State> = {},
+): MockImageValue<Model, State> => {
 	const model = config.model || modelGen.image({ seed: config.seed });
 	const imageData = getMockImageData({ seed: config.seed });
 
-	const value = buildImageField({
+	const value = buildImageFieldImage({
 		seed: config.seed,
 		imageData,
 		constraint: model.config.constraint,
-	});
+		state: config.state,
+	}) as MockImageValue<Model, State>;
 
 	for (const thumbnail of model.config.thumbnails) {
-		value[thumbnail.name] = buildImageField({
+		// 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,
 		});
 	}
 

package/src/value/integrationFields.ts

@@ -4,31 +4,43 @@ import * as changeCase from "change-case";
 import { createFaker } from "../lib/createFaker";
 import { getMockImageData } from "../lib/getMockImageData";
 
-import { MockValueConfig } from "../types";
+import { MockValueStateConfig, MockValueConfig } from "../types";
 
 export type MockIntegrationFieldsValueConfig<
 	Model extends prismicT.CustomTypeModelIntegrationFieldsField = prismicT.CustomTypeModelIntegrationFieldsField,
-	Blob extends unknown = unknown,
+	Blob = unknown,
+	State extends prismicT.FieldState = prismicT.FieldState,
 > = {
 	data?: Blob;
-} & MockValueConfig<Model>;
+} & MockValueConfig<Model> &
+	MockValueStateConfig<State>;
+
+export type MockIntegrationFieldsValue<
+	Blob = unknown,
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = prismicT.IntegrationFields<Blob, State>;
 
 export const integrationFields = <
 	Model extends prismicT.CustomTypeModelIntegrationFieldsField = prismicT.CustomTypeModelIntegrationFieldsField,
-	Blob extends unknown = unknown,
+	Blob = unknown,
+	State extends prismicT.FieldState = "filled",
 >(
-	config: MockIntegrationFieldsValueConfig<Model, Blob> = {},
-): prismicT.IntegrationFields<Blob> => {
+	config: MockIntegrationFieldsValueConfig<Model, Blob, State> = {},
+): MockIntegrationFieldsValue<Blob, State> => {
 	const faker = createFaker(config.seed);
 
 	const imageData = getMockImageData({ seed: config.seed });
 
-	return {
-		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,
-	};
+	return (
+		config.state === "empty"
+			? null
+			: {
+					id: faker.hash(7),
+					title: changeCase.capitalCase(faker.words(faker.range(1, 3))),
+					description: changeCase.sentenceCase(faker.words(faker.range(5, 10))),
+					image_url: imageData.url,
+					last_update: faker.date().getTime(),
+					blob: config.data as Blob,
+			  }
+	) as MockIntegrationFieldsValue<Blob, State>;
 };

package/src/value/keyText.ts

@@ -3,16 +3,26 @@ import * as changeCase from "change-case";
 
 import { createFaker } from "../lib/createFaker";
 
-import { MockValueConfig } from "../types";
+import { MockValueStateConfig, MockValueConfig } from "../types";
 
 export type MockKeyTextValueConfig<
 	Model extends prismicT.CustomTypeModelKeyTextField = prismicT.CustomTypeModelKeyTextField,
-> = MockValueConfig<Model>;
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = MockValueConfig<Model> & MockValueStateConfig<State>;
 
-export const keyText = (
-	config: MockKeyTextValueConfig = {},
-): prismicT.KeyTextField => {
+export type MockKeyTextValue<
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = prismicT.KeyTextField<State>;
+
+export const keyText = <
+	Model extends prismicT.CustomTypeModelKeyTextField = prismicT.CustomTypeModelKeyTextField,
+	State extends prismicT.FieldState = "filled",
+>(
+	config: MockKeyTextValueConfig<Model, State> = {},
+): MockKeyTextValue<State> => {
 	const faker = createFaker(config.seed);
 
-	return changeCase.sentenceCase(faker.lorem.words(3));
+	return (
+		config.state === "empty" ? null : changeCase.sentenceCase(faker.words(3))
+	) as MockKeyTextValue<State>;
 };

package/src/value/link.ts

@@ -2,7 +2,7 @@ import * as prismicT from "@prismicio/types";
 
 import { createFaker } from "../lib/createFaker";
 
-import { MockValueConfig } from "../types";
+import { MockValueStateConfig, MockValueConfig } from "../types";
 
 import * as modelGen from "../model";
 
@@ -10,89 +10,88 @@ import { contentRelationship } from "./contentRelationship";
 import { linkToMedia } from "./linkToMedia";
 
 export type MockLinkValueConfig<
-	LinkType extends prismicT.LinkType = prismicT.LinkType,
-	IsFilled extends boolean = true,
+	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 = prismicT.FieldState,
 > = {
 	type?: LinkType;
-	isFilled?: IsFilled;
 	withTargetBlank?: Model["config"]["allowTargetBlank"] extends undefined
 		? false
 		: boolean;
 	/**
 	 * A list of potential documents to which the field can be linked.
 	 */
-	linkableDocuments?: LinkType extends prismicT.LinkType.Document
+	linkableDocuments?: LinkType extends typeof prismicT.LinkType.Document
 		? prismicT.PrismicDocument[]
 		: never;
-} & MockValueConfig<Model>;
+} & MockValueConfig<Model> &
+	MockValueStateConfig<State>;
 
 type MockLinkValue<
-	LinkType extends prismicT.LinkType = prismicT.LinkType,
-	IsFilled extends boolean = true,
-> = IsFilled extends true
-	? LinkType extends prismicT.LinkType.Web
-		? prismicT.FilledLinkToWebField
-		: LinkType extends prismicT.LinkType.Media
-		? prismicT.FilledLinkToMediaField
-		: LinkType extends prismicT.LinkType.Document
-		? prismicT.FilledLinkToDocumentField
-		: never
-	: prismicT.EmptyLinkField<LinkType>;
+	LinkType extends typeof prismicT.LinkType[keyof typeof prismicT.LinkType] = typeof prismicT.LinkType[keyof typeof prismicT.LinkType],
+	State extends prismicT.FieldState = "filled",
+> = State extends "empty"
+	? prismicT.EmptyLinkField<LinkType>
+	: LinkType extends typeof prismicT.LinkType.Web
+	? prismicT.FilledLinkToWebField
+	: LinkType extends typeof prismicT.LinkType.Media
+	? prismicT.FilledLinkToMediaField
+	: LinkType extends typeof prismicT.LinkType.Document
+	? prismicT.FilledLinkToDocumentField
+	: never;
 
 export const link = <
-	LinkType extends prismicT.LinkType = prismicT.LinkType,
-	IsFilled extends boolean = true,
+	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: MockLinkValueConfig<LinkType, IsFilled, Model> = {},
-): MockLinkValue<LinkType, IsFilled> => {
+	config: MockLinkValueConfig<LinkType, Model, State> = {},
+): MockLinkValue<LinkType, State> => {
 	const faker = createFaker(config.seed);
 
-	const isFilled = config.isFilled ?? true;
-
 	const type =
 		config.type ||
-		faker.random.arrayElement([
+		faker.randomElement([
 			prismicT.LinkType.Web,
 			prismicT.LinkType.Document,
 			prismicT.LinkType.Media,
 		]);
 
-	if (isFilled) {
+	if (config.state === "empty") {
+		return {
+			link_type: type,
+		} as MockLinkValue<LinkType, State>;
+	} else {
 		switch (type) {
 			case prismicT.LinkType.Document: {
 				return contentRelationship({
 					seed: config.seed,
-					isFilled,
+					state: config.state,
 					linkableDocuments: config.linkableDocuments,
-				}) as MockLinkValue<LinkType, IsFilled>;
+				}) as unknown as MockLinkValue<LinkType, State>;
 			}
 
 			case prismicT.LinkType.Media: {
 				return linkToMedia({
 					seed: config.seed,
-					isFilled,
-				}) as MockLinkValue<LinkType, IsFilled>;
+					state: config.state,
+				}) as MockLinkValue<LinkType, State>;
 			}
 
-			case prismicT.LinkType.Web: {
+			case prismicT.LinkType.Web:
+			default: {
 				const model = config.model || modelGen.link({ seed: config.seed });
 
 				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, IsFilled>;
+				} as MockLinkValue<LinkType, State>;
 			}
 		}
 	}
-
-	return {
-		link_type: type,
-	} as MockLinkValue<LinkType, IsFilled>;
 };

package/src/value/linkToMedia.ts

@@ -1,44 +1,40 @@
 import * as prismicT from "@prismicio/types";
+import * as changeCase from "change-case";
 
 import { createFaker } from "../lib/createFaker";
 
-import { MockValueConfig } from "../types";
+import { MockValueStateConfig, MockValueConfig } from "../types";
 
 export type MockLinkToMediaValueConfig<
-	IsFilled extends boolean = true,
 	Model extends prismicT.CustomTypeModelLinkToMediaField = prismicT.CustomTypeModelLinkToMediaField,
-> = {
-	isFilled?: IsFilled;
-} & MockValueConfig<Model>;
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = MockValueConfig<Model> & MockValueStateConfig<State>;
 
-type MockLinkToMediaValue<IsFilled extends boolean = true> =
-	IsFilled extends true
-		? prismicT.FilledLinkToMediaField
-		: prismicT.EmptyLinkField<prismicT.LinkType.Media>;
+type MockLinkToMediaValue<
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = prismicT.LinkToMediaField<State>;
 
 export const linkToMedia = <
-	IsFilled extends boolean = true,
 	Model extends prismicT.CustomTypeModelLinkToMediaField = prismicT.CustomTypeModelLinkToMediaField,
+	State extends prismicT.FieldState = "filled",
 >(
-	config: MockLinkToMediaValueConfig<IsFilled, Model> = {},
-): MockLinkToMediaValue<IsFilled> => {
+	config: MockLinkToMediaValueConfig<Model, State> = {},
+): MockLinkToMediaValue<State> => {
 	const faker = createFaker(config.seed);
 
-	const isFilled = config.isFilled ?? true;
-
-	if (isFilled) {
+	if (config.state === "empty") {
 		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(),
-		} as prismicT.FilledLinkToMediaField;
+		} as MockLinkToMediaValue<State>;
 	} else {
 		return {
 			link_type: prismicT.LinkType.Media,
-		} as MockLinkToMediaValue<IsFilled>;
+			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>;
 	}
 };

package/src/value/number.ts

@@ -2,16 +2,26 @@ import * as prismicT from "@prismicio/types";
 
 import { createFaker } from "../lib/createFaker";
 
-import { MockValueConfig } from "../types";
+import { MockValueStateConfig, MockValueConfig } from "../types";
 
 export type MockNumberValueConfig<
 	Model extends prismicT.CustomTypeModelNumberField = prismicT.CustomTypeModelNumberField,
-> = MockValueConfig<Model>;
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = MockValueConfig<Model> & MockValueStateConfig<State>;
 
-export const number = (
-	config: MockNumberValueConfig = {},
-): prismicT.NumberField => {
+export type MockNumberValue<
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = prismicT.NumberField<State>;
+
+export const number = <
+	Model extends prismicT.CustomTypeModelNumberField = prismicT.CustomTypeModelNumberField,
+	State extends prismicT.FieldState = "filled",
+>(
+	config: MockNumberValueConfig<Model, State> = {},
+): MockNumberValue<State> => {
 	const faker = createFaker(config.seed);
 
-	return faker.datatype.number();
+	return (
+		config.state === "empty" ? null : faker.range(1, 100)
+	) as MockNumberValue<State>;
 };

package/src/value/richText/embed.ts

@@ -10,8 +10,8 @@ type MockRichTextEmbedValueConfig = MockRichTextValueConfig;
 export const embed = (
 	config: MockRichTextEmbedValueConfig = {},
 ): prismicT.RTEmbedNode | undefined => {
-	const embedData = getMockEmbedData({ seed: config.seed });
-	const embedField = buildEmbedField({ seed: config.seed, embedData });
+	const data = getMockEmbedData({ seed: config.seed });
+	const embedField = buildEmbedField({ seed: config.seed, data });
 
 	return {
 		type: prismicT.RichTextNodeType.embed,