@prismicio/mock 0.0.6 → 0.0.9

package/src/value/richText/heading.ts

@@ -8,12 +8,12 @@ import { MockRichTextValueConfig } from "../../types";
 import * as modelGen from "../../model";
 
 type RichTextNodeTitleType =
-	| prismicT.RichTextNodeType.heading1
-	| prismicT.RichTextNodeType.heading2
-	| prismicT.RichTextNodeType.heading3
-	| prismicT.RichTextNodeType.heading4
-	| prismicT.RichTextNodeType.heading5
-	| prismicT.RichTextNodeType.heading6;
+	| typeof prismicT.RichTextNodeType.heading1
+	| typeof prismicT.RichTextNodeType.heading2
+	| typeof prismicT.RichTextNodeType.heading3
+	| typeof prismicT.RichTextNodeType.heading4
+	| typeof prismicT.RichTextNodeType.heading5
+	| typeof prismicT.RichTextNodeType.heading6;
 
 type RTHeadingNode =
 	| prismicT.RTHeading1Node
@@ -61,27 +61,20 @@ export const heading = (
 				prismicT.RichTextNodeType.heading4,
 				prismicT.RichTextNodeType.heading5,
 				prismicT.RichTextNodeType.heading6,
-			].includes(type as prismicT.RichTextNodeType),
+			].includes(type as RichTextNodeTitleType),
 		) as RichTextNodeTitleType[];
-	const type = faker.random.arrayElement(types);
+	const type = faker.randomElement(types);
 
 	if (type) {
 		const patternKey =
 			config.pattern ||
-			faker.random.arrayElement(
-				Object.keys(patterns) as (keyof typeof patterns)[],
-			);
+			faker.randomElement(Object.keys(patterns) as (keyof typeof patterns)[]);
 		const pattern = patterns[patternKey];
 
 		return {
 			type,
 			text: changeCase.capitalCase(
-				faker.lorem.words(
-					faker.datatype.number({
-						min: pattern.minWords,
-						max: pattern.maxWords,
-					}),
-				),
+				faker.words(faker.range(pattern.minWords, pattern.maxWords)),
 			),
 			spans: [],
 		};

package/src/value/richText/image.ts

@@ -1,6 +1,6 @@
 import * as prismicT from "@prismicio/types";
 
-import { buildImageField } from "../../lib/buildImageField";
+import { buildImageFieldImage } from "../../lib/buildImageFieldImage";
 import { getMockImageData } from "../../lib/getMockImageData";
 
 import { MockRichTextValueConfig } from "../../types";
@@ -11,15 +11,17 @@ export const image = (
 	config: MockRichTextImageValueConfig = {},
 ): prismicT.RTImageNode | undefined => {
 	const imageData = getMockImageData({ seed: config.seed });
-	const imageField = buildImageField({ seed: config.seed, imageData });
+	const imageField = buildImageFieldImage({
+		seed: config.seed,
+		imageData,
+		state: "filled",
+	});
 
 	return {
 		type: prismicT.RichTextNodeType.image,
 		alt: imageField.alt,
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		url: imageField.url!,
+		url: imageField.url,
 		copyright: imageField.copyright,
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		dimensions: imageField.dimensions!,
+		dimensions: imageField.dimensions,
 	};
 };

package/src/value/richText/index.ts

@@ -70,29 +70,24 @@ export const richText = (
 	if (types.length > 0) {
 		const patternKey =
 			config.pattern ||
-			faker.random.arrayElement(
-				Object.keys(patterns) as (keyof typeof patterns)[],
-			);
+			faker.randomElement(Object.keys(patterns) as (keyof typeof patterns)[]);
 		const pattern = patterns[patternKey];
 
 		const blockCount = supportsMultipleBlocks
-			? faker.datatype.number({
-					min: pattern.blockCountMin,
-					max: pattern.blockCountMax,
-			  })
+			? faker.range(pattern.blockCountMin, pattern.blockCountMax)
 			: 1;
 
 		return Array(blockCount)
 			.fill(undefined)
 			.map(() => {
-				const type = faker.random.arrayElement(types);
+				const type = faker.randomElement(types);
 				const generator = generators[type];
 
 				return generator({ seed: config.seed, model });
 			})
 			.flat()
 			.filter((block): block is prismicT.RTNode => block !== undefined)
-			.slice(0, blockCount);
+			.slice(0, blockCount) as prismicT.RichTextField;
 	} else {
 		return [];
 	}

package/src/value/richText/list.ts

@@ -1,4 +1,5 @@
 import * as prismicT from "@prismicio/types";
+import * as changeCase from "change-case";
 
 import { createFaker } from "../../lib/createFaker";
 
@@ -30,22 +31,17 @@ export const list = (
 
 	const patternKey =
 		config.pattern ||
-		faker.random.arrayElement(
-			Object.keys(patterns) as (keyof typeof patterns)[],
-		);
+		faker.randomElement(Object.keys(patterns) as (keyof typeof patterns)[]);
 	const pattern = patterns[patternKey];
 
-	const itemsCount = faker.datatype.number({
-		min: pattern.minItems,
-		max: pattern.maxItems,
-	});
+	const itemsCount = faker.range(pattern.minItems, pattern.maxItems);
 
 	return Array(itemsCount)
 		.fill(undefined)
 		.map(() => {
 			return {
 				type: prismicT.RichTextNodeType.listItem,
-				text: faker.lorem.sentence(),
+				text: changeCase.sentenceCase(faker.words(faker.range(5, 15))),
 				spans: [],
 			};
 		});

package/src/value/richText/oList.ts

@@ -1,4 +1,5 @@
 import * as prismicT from "@prismicio/types";
+import * as changeCase from "change-case";
 
 import { createFaker } from "../../lib/createFaker";
 
@@ -30,22 +31,17 @@ export const oList = (
 
 	const patternKey =
 		config.pattern ||
-		faker.random.arrayElement(
-			Object.keys(patterns) as (keyof typeof patterns)[],
-		);
+		faker.randomElement(Object.keys(patterns) as (keyof typeof patterns)[]);
 	const pattern = patterns[patternKey];
 
-	const itemsCount = faker.datatype.number({
-		min: pattern.minItems,
-		max: pattern.maxItems,
-	});
+	const itemsCount = faker.range(pattern.minItems, pattern.maxItems);
 
 	return Array(itemsCount)
 		.fill(undefined)
 		.map(() => {
 			return {
 				type: prismicT.RichTextNodeType.oListItem,
-				text: faker.lorem.sentence(),
+				text: changeCase.sentenceCase(faker.words(faker.range(5, 15))),
 				spans: [],
 			};
 		});

package/src/value/richText/paragraph.ts

@@ -1,4 +1,5 @@
 import * as prismicT from "@prismicio/types";
+import * as changeCase from "change-case";
 
 import { createFaker } from "../../lib/createFaker";
 
@@ -27,14 +28,17 @@ export const paragraph = (
 
 	const patternKey =
 		config.pattern ||
-		faker.random.arrayElement(
-			Object.keys(patterns) as (keyof typeof patterns)[],
-		);
+		faker.randomElement(Object.keys(patterns) as (keyof typeof patterns)[]);
 	const pattern = patterns[patternKey];
 
+	const text = Array.from(
+		{ length: pattern.sentenceCount },
+		() => changeCase.sentenceCase(faker.words(faker.range(5, 15))) + ".",
+	).join(" ");
+
 	return {
 		type: prismicT.RichTextNodeType.paragraph,
-		text: faker.lorem.paragraph(pattern.sentenceCount),
+		text,
 		spans: [],
 	};
 };

package/src/value/richText/preformatted.ts

@@ -1,4 +1,5 @@
 import * as prismicT from "@prismicio/types";
+import * as changeCase from "change-case";
 
 import { createFaker } from "../../lib/createFaker";
 
@@ -27,15 +28,18 @@ export const preformatted = (
 
 	const patternKey =
 		config.pattern ||
-		faker.random.arrayElement(
-			Object.keys(patterns) as (keyof typeof patterns)[],
-		);
+		faker.randomElement(Object.keys(patterns) as (keyof typeof patterns)[]);
 	const pattern = patterns[patternKey];
 
+	// TODO: Use code, not lorem ipsum.
+	const text = Array.from(
+		{ length: pattern.sentenceCount },
+		() => changeCase.sentenceCase(faker.words(faker.range(5, 15))) + ".",
+	).join(" ");
+
 	return {
 		type: prismicT.RichTextNodeType.preformatted,
-		// TODO: Use code, not lorem ipsum.
-		text: faker.lorem.paragraph(pattern.sentenceCount),
+		text,
 		spans: [],
 	};
 };

package/src/value/select.ts

@@ -2,23 +2,38 @@ 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";
 
 export type MockSelectValueConfig<
 	Model extends prismicT.CustomTypeModelSelectField = prismicT.CustomTypeModelSelectField,
-> = MockValueConfig<Model>;
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = MockValueConfig<Model> & MockValueStateConfig<State>;
 
-export const select = (
-	config: MockSelectValueConfig = {},
-): prismicT.SelectField => {
+export type MockSelectValue<
+	Model extends prismicT.CustomTypeModelSelectField = prismicT.CustomTypeModelSelectField,
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = prismicT.SelectField<Model["config"]["options"][number], State>;
+
+export const select = <
+	Model extends prismicT.CustomTypeModelSelectField = prismicT.CustomTypeModelSelectField,
+	State extends prismicT.FieldState = "filled",
+>(
+	config: MockSelectValueConfig<Model, State> = {},
+): MockSelectValue<Model, State> => {
 	const faker = createFaker(config.seed);
 
 	const model = config.model || modelGen.select({ seed: config.seed });
 	const defaultValue = model.config.default_value;
 
-	return typeof defaultValue === "string" && faker.datatype.boolean()
-		? defaultValue
-		: faker.random.arrayElement(model.config.options);
+	if (config.state === "empty") {
+		return null as MockSelectValue<Model, State>;
+	} else {
+		return (
+			typeof defaultValue === "string" && faker.boolean()
+				? defaultValue
+				: faker.randomElement(model.config.options)
+		) as MockSelectValue<Model, State>;
+	}
 };

package/src/value/sharedSlice.ts

@@ -14,7 +14,7 @@ export type MockSharedSliceValueConfig<
 	Model extends prismicT.SharedSliceModel = prismicT.SharedSliceModel,
 > = Pick<
 	MockSharedSliceVariationValueConfig,
-	"pattern" | "primaryFieldConfigs" | "itemsFieldConfigs"
+	"itemsCount" | "primaryFieldConfigs" | "itemsFieldConfigs"
 > &
 	MockValueConfig<Model>;
 
@@ -26,12 +26,12 @@ export const sharedSlice = <
 	const faker = createFaker(config.seed);
 
 	const model = config.model || modelGen.sharedSlice({ seed: config.seed });
-	const variationModel = faker.random.arrayElement(model.variations);
+	const variationModel = faker.randomElement(model.variations);
 
 	return sharedSliceVariation({
 		seed: config.seed,
 		model: variationModel,
-		pattern: config.pattern,
+		itemsCount: config.itemsCount,
 		type: model.id,
 		primaryFieldConfigs: config.primaryFieldConfigs,
 		itemsFieldConfigs: config.itemsFieldConfigs,

package/src/value/sharedSliceVariation.ts

@@ -1,5 +1,4 @@
 import * as prismicT from "@prismicio/types";
-import * as changeCase from "change-case";
 
 import { MockValueConfig, ModelValue } from "../types";
 
@@ -12,31 +11,12 @@ import {
 
 import * as modelGen from "../model";
 
-const patterns = {
-	none: {
-		minItems: 0,
-		maxItems: 0,
-	},
-	short: {
-		minItems: 1,
-		maxItems: 3,
-	},
-	medium: {
-		minItems: 3,
-		maxItems: 6,
-	},
-	long: {
-		minItems: 6,
-		maxItems: 12,
-	},
-} as const;
-
 export type MockSharedSliceVariationValueConfig<
 	Model extends prismicT.SharedSliceModelVariation = prismicT.SharedSliceModelVariation,
 > = {
 	type?: string;
 	label?: string;
-	pattern?: keyof typeof patterns;
+	itemsCount?: number;
 	primaryFieldConfigs?: ValueForModelMapConfigs;
 	itemsFieldConfigs?: ValueForModelMapConfigs;
 } & MockValueConfig<Model>;
@@ -51,30 +31,18 @@ export const sharedSliceVariation = <
 	const model =
 		config.model || modelGen.sharedSliceVariation({ seed: config.seed });
 
-	const patternKey =
-		config.pattern ||
-		faker.random.arrayElement(
-			Object.keys(patterns) as (keyof typeof patterns)[],
-		);
-	const pattern = patterns[patternKey];
-
 	const sliceType = config.type ?? generateFieldId({ seed: config.seed });
-	const sliceLabel =
-		config.label ?? changeCase.capitalCase(faker.company.bsNoun());
 
 	const itemsCount =
 		Object.keys(model.items).length > 0
-			? faker.datatype.number({
-					min: pattern.minItems,
-					max: pattern.maxItems,
-			  })
+			? config.itemsCount ?? faker.range(1, 6)
 			: 0;
 
 	return {
 		slice_type: sliceType,
-		slice_label: sliceLabel,
+		slice_label: null,
 		variation: model.id,
-		version: faker.git.shortSha(),
+		version: faker.hash(7),
 		primary: valueForModelMap({
 			seed: config.seed,
 			map: model.primary,

package/src/value/slice.ts

@@ -12,31 +12,12 @@ import {
 
 import * as modelGen from "../model";
 
-const patterns = {
-	none: {
-		minItems: 0,
-		maxItems: 0,
-	},
-	short: {
-		minItems: 1,
-		maxItems: 3,
-	},
-	medium: {
-		minItems: 3,
-		maxItems: 6,
-	},
-	long: {
-		minItems: 6,
-		maxItems: 12,
-	},
-} as const;
-
 export type MockSliceValueConfig<
 	Model extends prismicT.CustomTypeModelSlice = prismicT.CustomTypeModelSlice,
 > = {
 	type?: string;
 	label?: string | null;
-	pattern?: keyof typeof patterns;
+	itemsCount?: number;
 	primaryFieldConfigs?: ValueForModelMapConfigs;
 	itemsFieldConfigs?: ValueForModelMapConfigs;
 } & MockValueConfig<Model>;
@@ -50,25 +31,15 @@ export const slice = <
 
 	const model = config.model || modelGen.slice({ seed: config.seed });
 
-	const patternKey =
-		config.pattern ||
-		faker.random.arrayElement(
-			Object.keys(patterns) as (keyof typeof patterns)[],
-		);
-	const pattern = patterns[patternKey];
-
 	const sliceType = config.type ?? generateFieldId({ seed: config.seed });
 	const sliceLabel =
 		config.label !== undefined
 			? config.label
-			: changeCase.capitalCase(faker.company.bsNoun());
+			: changeCase.capitalCase(faker.words(faker.range(1, 2)));
 
 	const itemsCount =
 		Object.keys(model.repeat).length > 0
-			? faker.datatype.number({
-					min: pattern.minItems,
-					max: pattern.maxItems,
-			  })
+			? config.itemsCount ?? faker.range(1, 6)
 			: 0;
 
 	return {

package/src/value/sliceZone.ts

@@ -3,97 +3,82 @@ import * as prismicT from "@prismicio/types";
 import { createFaker } from "../lib/createFaker";
 import { ValueForModelMapConfigs } from "../lib/valueForModelMap";
 
-import { MockValueConfig, ModelValue } from "../types";
+import { MockValueConfig, MockValueStateConfig, ModelValue } from "../types";
 
 import * as modelGen from "../model";
 
 import { slice } from "./slice";
 import { sharedSlice } from "./sharedSlice";
 
-const patterns = {
-	short: {
-		minItems: 1,
-		maxItems: 3,
-	},
-	medium: {
-		minItems: 3,
-		maxItems: 6,
-	},
-	long: {
-		minItems: 6,
-		maxItems: 12,
-	},
-} as const;
-
 export type MockSliceZoneValueConfig<
 	Model extends prismicT.CustomTypeModelSliceZoneField = prismicT.CustomTypeModelSliceZoneField,
+	State extends prismicT.FieldState = prismicT.FieldState,
 > = {
 	sharedSliceModels?: prismicT.SharedSliceModel[];
-	pattern?: keyof typeof patterns;
+	itemsCount?: State extends "empty" ? 0 : number;
 	primaryFieldConfigs?: ValueForModelMapConfigs;
 	itemsFieldConfigs?: ValueForModelMapConfigs;
-} & MockValueConfig<Model>;
+} & MockValueConfig<Model> &
+	MockValueStateConfig<State>;
 
 export const sliceZone = <
 	Model extends prismicT.CustomTypeModelSliceZoneField = prismicT.CustomTypeModelSliceZoneField,
+	State extends prismicT.FieldState = prismicT.FieldState,
 >(
-	config: MockSliceZoneValueConfig<Model> = {},
-): ModelValue<Model> => {
-	const faker = createFaker(config.seed);
-
-	const model = config.model || modelGen.sliceZone({ seed: config.seed });
+	config: MockSliceZoneValueConfig<Model, State> = {},
+): ModelValue<Model, State> => {
+	if (config.state === "empty") {
+		return [] as ModelValue<Model, State>;
+	} else {
+		const faker = createFaker(config.seed);
 
-	const patternKey =
-		config.pattern ||
-		faker.random.arrayElement(
-			Object.keys(patterns) as (keyof typeof patterns)[],
-		);
-	const pattern = patterns[patternKey];
+		const model = config.model || modelGen.sliceZone({ seed: config.seed });
 
-	const itemsCount = faker.datatype.number({
-		min: pattern.minItems,
-		max: pattern.maxItems,
-	});
+		if (Object.keys(model.config.choices).length > 0) {
+			const itemsCount = config.itemsCount ?? faker.range(1, 6);
 
-	return Array(itemsCount)
-		.fill(undefined)
-		.map(() => {
-			const choices = Object.entries(model.config.choices);
-			const [choiceType, choiceModel] = faker.random.arrayElement(choices);
+			return Array(itemsCount)
+				.fill(undefined)
+				.map(() => {
+					const choices = Object.entries(model.config.choices);
+					const [choiceType, choiceModel] = faker.randomElement(choices);
 
-			const choiceLabels = model.config.labels[choiceType] || [];
-			const choiceLabel = faker.random.arrayElement(choiceLabels);
+					const choiceLabels = model.config.labels[choiceType] || [];
+					const choiceLabel = faker.randomElement(choiceLabels);
 
-			switch (choiceModel.type) {
-				case prismicT.CustomTypeModelSliceType.Slice: {
-					return slice({
-						seed: config.seed,
-						model: choiceModel,
-						type: choiceType,
-						label: choiceLabel ? choiceLabel.name : null,
-						primaryFieldConfigs: config.primaryFieldConfigs,
-						itemsFieldConfigs: config.itemsFieldConfigs,
-					});
-				}
+					switch (choiceModel.type) {
+						case prismicT.CustomTypeModelSliceType.Slice: {
+							return slice({
+								seed: config.seed,
+								model: choiceModel,
+								type: choiceType,
+								label: choiceLabel ? choiceLabel.name : null,
+								primaryFieldConfigs: config.primaryFieldConfigs,
+								itemsFieldConfigs: config.itemsFieldConfigs,
+							});
+						}
 
-				case prismicT.CustomTypeModelSliceType.SharedSlice: {
-					const sharedSliceModel = config.sharedSliceModels?.find(
-						(sharedSliceModel) => sharedSliceModel.id === choiceType,
-					);
+						case prismicT.CustomTypeModelSliceType.SharedSlice: {
+							const sharedSliceModel = config.sharedSliceModels?.find(
+								(sharedSliceModel) => sharedSliceModel.id === choiceType,
+							);
 
-					if (sharedSliceModel) {
-						return sharedSlice({
-							seed: config.seed,
-							model: sharedSliceModel,
-							primaryFieldConfigs: config.primaryFieldConfigs,
-							itemsFieldConfigs: config.itemsFieldConfigs,
-						});
+							if (sharedSliceModel) {
+								return sharedSlice({
+									seed: config.seed,
+									model: sharedSliceModel,
+									primaryFieldConfigs: config.primaryFieldConfigs,
+									itemsFieldConfigs: config.itemsFieldConfigs,
+								});
+							}
+						}
 					}
-				}
-			}
-		})
-		.filter(
-			(slice): slice is prismicT.Slice | prismicT.SharedSlice =>
-				slice !== undefined,
-		) as ModelValue<Model>;
+				})
+				.filter(
+					(slice): slice is NonNullable<typeof slice> => slice !== undefined,
+				) as ModelValue<Model, State>;
+		} else {
+			return [] as unknown as ModelValue<Model, State>;
+		}
+	}
 };

package/src/value/timestamp.ts

@@ -2,29 +2,55 @@ import * as prismicT from "@prismicio/types";
 
 import { createFaker } from "../lib/createFaker";
 
-import { MockValueConfig } from "../types";
+import { MockValueStateConfig, MockValueConfig } from "../types";
 
 export type MockTimestampValueConfig<
 	Model extends prismicT.CustomTypeModelTimestampField = prismicT.CustomTypeModelTimestampField,
+	State extends prismicT.FieldState = prismicT.FieldState,
 > = {
 	after?: Date;
 	before?: Date;
-} & MockValueConfig<Model>;
+} & MockValueConfig<Model> &
+	MockValueStateConfig<State>;
 
-export const timestamp = (
-	config: MockTimestampValueConfig = {},
-): prismicT.TimestampField => {
+export type MockTimestampValue<
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = prismicT.TimestampField<State>;
+
+export const timestamp = <
+	Model extends prismicT.CustomTypeModelTimestampField = prismicT.CustomTypeModelTimestampField,
+	State extends prismicT.FieldState = "filled",
+>(
+	config: MockTimestampValueConfig<Model, State> = {},
+): MockTimestampValue<State> => {
 	const faker = createFaker(config.seed);
 
-	// Faker seems to have problems accepting parameters for `faker.date.between`
-	// if the parameters are too precise. We can get around this by only using
-	// generated dates, not timestamps.
-	const after =
-		config.after ||
-		faker.date.past(20, new Date("2021-03-07")).toISOString().split("T")[0];
-	const before =
-		config.before ||
-		faker.date.future(20, new Date("2021-03-07")).toISOString().split("T")[0];
-
-	return faker.date.between(after, before).toISOString();
+	if (config.state === "empty") {
+		return null as MockTimestampValue<State>;
+	} else {
+		let date: Date;
+
+		// Working with Date objects produces non-deterministic values;
+		// machines can return different values due to differing
+		// timezones and other unknown factors. To get around this, we
+		// can can remove time from the given values and only use their dates.
+		const after = config.after
+			? new Date(config.after.toISOString().split("T")[0])
+			: undefined;
+		const before = config.before
+			? new Date(config.before.toISOString().split("T")[0])
+			: undefined;
+
+		if (after && before) {
+			date = faker.dateBetween(after, before);
+		} else if (after) {
+			date = faker.dateAfter(after);
+		} else if (before) {
+			date = faker.dateBefore(before);
+		} else {
+			date = faker.date();
+		}
+
+		return date.toISOString() as MockTimestampValue<State>;
+	}
 };