@prismicio/mock 0.0.8 → 0.1.0

package/src/value/number.ts

@@ -17,11 +17,11 @@ export const number = <
 	Model extends prismicT.CustomTypeModelNumberField = prismicT.CustomTypeModelNumberField,
 	State extends prismicT.FieldState = "filled",
 >(
-	config: MockNumberValueConfig<Model, State> = {},
+	config: MockNumberValueConfig<Model, State>,
 ): MockNumberValue<State> => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
 	return (
-		config.state === "empty" ? null : faker.datatype.number()
+		config.state === "empty" ? null : faker.range(1, 100)
 	) as MockNumberValue<State>;
 };

package/src/value/richText/embed.ts

@@ -1,6 +1,7 @@
 import * as prismicT from "@prismicio/types";
 
 import { buildEmbedField } from "../../lib/buildEmbedField";
+import { createFaker } from "../../lib/createFaker";
 import { getMockEmbedData } from "../../lib/getMockEmbedData";
 
 import { MockRichTextValueConfig } from "../../types";
@@ -8,10 +9,12 @@ import { MockRichTextValueConfig } from "../../types";
 type MockRichTextEmbedValueConfig = MockRichTextValueConfig;
 
 export const embed = (
-	config: MockRichTextEmbedValueConfig = {},
+	config: MockRichTextEmbedValueConfig,
 ): prismicT.RTEmbedNode | undefined => {
-	const embedData = getMockEmbedData({ seed: config.seed });
-	const embedField = buildEmbedField({ seed: config.seed, embedData });
+	const faker = config.faker || createFaker(config.seed);
+
+	const data = getMockEmbedData({ faker });
+	const embedField = buildEmbedField({ faker, data });
 
 	return {
 		type: prismicT.RichTextNodeType.embed,

package/src/value/richText/heading.ts

@@ -42,46 +42,51 @@ export type MockRichTextHeadingValueConfig = {
 	pattern?: keyof typeof patterns;
 } & MockRichTextValueConfig;
 
+const headingNoteTypes = [
+	prismicT.RichTextNodeType.heading1,
+	prismicT.RichTextNodeType.heading2,
+	prismicT.RichTextNodeType.heading3,
+	prismicT.RichTextNodeType.heading4,
+	prismicT.RichTextNodeType.heading5,
+	prismicT.RichTextNodeType.heading6,
+];
+
 export const heading = (
-	config: MockRichTextHeadingValueConfig = {},
+	config: MockRichTextHeadingValueConfig,
 ): RTHeadingNode | undefined => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
+
+	const model = config.model || modelGen.title({ faker });
 
-	const model = config.model || modelGen.title({ seed: config.seed });
+	let types: RichTextNodeTitleType[] = [];
+	if (model.config) {
+		if ("single" in model.config && model.config.single) {
+			types = model.config.single
+				.split(",")
+				.filter((type): type is RichTextNodeTitleType =>
+					headingNoteTypes.includes(type as RichTextNodeTitleType),
+				);
+		} else if ("multi" in model.config && model.config.multi) {
+			types = model.config.multi
+				.split(",")
+				.filter((type): type is RichTextNodeTitleType =>
+					headingNoteTypes.includes(type as RichTextNodeTitleType),
+				);
+		}
+	}
 
-	const types = (
-		"single" in model.config ? model.config.single : model.config.multi
-	)
-		.split(",")
-		.filter((type) =>
-			[
-				prismicT.RichTextNodeType.heading1,
-				prismicT.RichTextNodeType.heading2,
-				prismicT.RichTextNodeType.heading3,
-				prismicT.RichTextNodeType.heading4,
-				prismicT.RichTextNodeType.heading5,
-				prismicT.RichTextNodeType.heading6,
-			].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,7 @@
 import * as prismicT from "@prismicio/types";
 
 import { buildImageFieldImage } from "../../lib/buildImageFieldImage";
+import { createFaker } from "../../lib/createFaker";
 import { getMockImageData } from "../../lib/getMockImageData";
 
 import { MockRichTextValueConfig } from "../../types";
@@ -8,22 +9,22 @@ import { MockRichTextValueConfig } from "../../types";
 type MockRichTextImageValueConfig = MockRichTextValueConfig;
 
 export const image = (
-	config: MockRichTextImageValueConfig = {},
+	config: MockRichTextImageValueConfig,
 ): prismicT.RTImageNode | undefined => {
-	const imageData = getMockImageData({ seed: config.seed });
+	const faker = config.faker || createFaker(config.seed);
+
+	const imageData = getMockImageData({ faker });
 	const imageField = buildImageFieldImage({
-		seed: config.seed,
+		faker,
 		imageData,
-		state: false,
+		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

@@ -2,7 +2,10 @@ import * as prismicT from "@prismicio/types";
 
 import { createFaker } from "../../lib/createFaker";
 
-import { MockRichTextValueConfig as BaseMockRichTextValueConfig } from "../../types";
+import {
+	MockRichTextValueConfig as BaseMockRichTextValueConfig,
+	MockValueStateConfig,
+} from "../../types";
 
 import * as modelGen from "../../model";
 import { heading } from "./heading";
@@ -28,10 +31,6 @@ const patterns = {
 	},
 } as const;
 
-export type MockRichTextValueConfig = {
-	pattern?: keyof typeof patterns;
-} & BaseMockRichTextValueConfig<prismicT.CustomTypeModelRichTextField>;
-
 const generators = {
 	[prismicT.RichTextNodeType.heading1]: heading,
 	[prismicT.RichTextNodeType.heading2]: heading,
@@ -47,53 +46,77 @@ const generators = {
 	[prismicT.RichTextNodeType.embed]: embed,
 };
 
-export const richText = (
-	config: MockRichTextValueConfig = {},
-): prismicT.RichTextField => {
-	const faker = createFaker(config.seed);
+export type MockRichTextValueConfig<
+	Model extends prismicT.CustomTypeModelRichTextField = prismicT.CustomTypeModelRichTextField,
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = {
+	pattern?: keyof typeof patterns;
+} & BaseMockRichTextValueConfig<Model> &
+	MockValueStateConfig<State>;
+
+export type MockRichTextValue<
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = prismicT.RichTextField<State>;
 
-	const model =
-		config.model ||
-		modelGen.richText({
-			seed: config.seed,
-			withMultipleBlocks: true,
-		});
-	const supportsMultipleBlocks = "multi" in model.config;
-	const types = (
-		"multi" in model.config ? model.config.multi : model.config.single
-	)
-		.split(",")
-		.filter((type) =>
-			Object.keys(generators).includes(type),
-		) as prismicT.RTNode["type"][];
+export const richText = <
+	Model extends prismicT.CustomTypeModelRichTextField = prismicT.CustomTypeModelRichTextField,
+	State extends prismicT.FieldState = prismicT.FieldState,
+>(
+	config: MockRichTextValueConfig<Model, State>,
+): MockRichTextValue<State> => {
+	const faker = config.faker || createFaker(config.seed);
 
-	if (types.length > 0) {
-		const patternKey =
-			config.pattern ||
-			faker.random.arrayElement(
-				Object.keys(patterns) as (keyof typeof patterns)[],
-			);
-		const pattern = patterns[patternKey];
+	if (config.state === "empty") {
+		return [] as MockRichTextValue<State>;
+	} else {
+		const model =
+			config.model ||
+			modelGen.richText({
+				faker,
+				withMultipleBlocks: true,
+			});
+		const supportsMultipleBlocks = model.config && "multi" in model.config;
 
-		const blockCount = supportsMultipleBlocks
-			? faker.datatype.number({
-					min: pattern.blockCountMin,
-					max: pattern.blockCountMax,
-			  })
-			: 1;
+		let types: prismicT.RTNode["type"][] = [];
+		if (model.config) {
+			if ("multi" in model.config && model.config.multi) {
+				types = model.config.multi
+					.split(",")
+					.filter((type): type is prismicT.RTNode["type"] =>
+						Object.keys(generators).includes(type),
+					);
+			} else if ("single" in model.config && model.config.single) {
+				types = model.config.single
+					.split(",")
+					.filter((type): type is prismicT.RTNode["type"] =>
+						Object.keys(generators).includes(type),
+					);
+			}
+		}
 
-		return Array(blockCount)
-			.fill(undefined)
-			.map(() => {
-				const type = faker.random.arrayElement(types);
-				const generator = generators[type];
+		if (types.length > 0) {
+			const patternKey =
+				config.pattern ||
+				faker.randomElement(Object.keys(patterns) as (keyof typeof patterns)[]);
+			const pattern = patterns[patternKey];
 
-				return generator({ seed: config.seed, model });
-			})
-			.flat()
-			.filter((block): block is prismicT.RTNode => block !== undefined)
-			.slice(0, blockCount) as prismicT.RichTextField;
-	} else {
-		return [];
+			const blockCount = supportsMultipleBlocks
+				? faker.range(pattern.blockCountMin, pattern.blockCountMax)
+				: 1;
+
+			return Array(blockCount)
+				.fill(undefined)
+				.map(() => {
+					const type = faker.randomElement(types);
+					const generator = generators[type];
+
+					return generator({ faker, model });
+				})
+				.flat()
+				.filter((block): block is prismicT.RTNode => block !== undefined)
+				.slice(0, blockCount) as MockRichTextValue<State>;
+		} else {
+			return [] as MockRichTextValue<State>;
+		}
 	}
 };

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";
 
@@ -24,28 +25,23 @@ type MockRichTextListValueConfig = {
 } & MockRichTextValueConfig;
 
 export const list = (
-	config: MockRichTextListValueConfig = {},
+	config: MockRichTextListValueConfig,
 ): prismicT.RTListItemNode[] | undefined => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
 	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";
 
@@ -24,28 +25,23 @@ type MockRichTextOListValueConfig = {
 } & MockRichTextValueConfig;
 
 export const oList = (
-	config: MockRichTextOListValueConfig = {},
+	config: MockRichTextOListValueConfig,
 ): prismicT.RTOListItemNode[] | undefined => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
 	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";
 
@@ -21,20 +22,23 @@ type MockRichTextParagraphValueConfig = {
 } & MockRichTextValueConfig;
 
 export const paragraph = (
-	config: MockRichTextParagraphValueConfig = {},
+	config: MockRichTextParagraphValueConfig,
 ): prismicT.RTParagraphNode | undefined => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
 	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";
 
@@ -21,21 +22,24 @@ type MockRichTextPreformattedValueConfig = {
 } & MockRichTextValueConfig;
 
 export const preformatted = (
-	config: MockRichTextPreformattedValueConfig = {},
+	config: MockRichTextPreformattedValueConfig,
 ): prismicT.RTPreformattedNode | undefined => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
 	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

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

package/src/value/sharedSlice.ts

@@ -21,15 +21,15 @@ export type MockSharedSliceValueConfig<
 export const sharedSlice = <
 	Model extends prismicT.SharedSliceModel = prismicT.SharedSliceModel,
 >(
-	config: MockSharedSliceValueConfig<Model> = {},
+	config: MockSharedSliceValueConfig<Model>,
 ): ModelValue<Model> => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
-	const model = config.model || modelGen.sharedSlice({ seed: config.seed });
-	const variationModel = faker.random.arrayElement(model.variations);
+	const model = config.model || modelGen.sharedSlice({ faker });
+	const variationModel = faker.randomElement(model.variations);
 
 	return sharedSliceVariation({
-		seed: config.seed,
+		faker,
 		model: variationModel,
 		itemsCount: config.itemsCount,
 		type: model.id,

package/src/value/sharedSliceVariation.ts

@@ -24,40 +24,35 @@ export type MockSharedSliceVariationValueConfig<
 export const sharedSliceVariation = <
 	Model extends prismicT.SharedSliceModelVariation = prismicT.SharedSliceModelVariation,
 >(
-	config: MockSharedSliceVariationValueConfig<Model> = {},
+	config: MockSharedSliceVariationValueConfig<Model>,
 ): ModelValue<Model> => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
-	const model =
-		config.model || modelGen.sharedSliceVariation({ seed: config.seed });
+	const model = config.model || modelGen.sharedSliceVariation({ faker });
 
-	const sliceType = config.type ?? generateFieldId({ seed: config.seed });
+	const sliceType = config.type ?? generateFieldId({ faker });
 
 	const itemsCount =
-		Object.keys(model.items).length > 0
-			? config.itemsCount ??
-			  faker.datatype.number({
-					min: 1,
-					max: 6,
-			  })
+		model.items && Object.keys(model.items).length > 0
+			? config.itemsCount ?? faker.range(1, 6)
 			: 0;
 
 	return {
 		slice_type: sliceType,
 		slice_label: null,
 		variation: model.id,
-		version: faker.git.shortSha(),
+		version: faker.hash(7),
 		primary: valueForModelMap({
-			seed: config.seed,
-			map: model.primary,
+			faker,
+			map: model.primary || {},
 			configs: config.primaryFieldConfigs,
 		}),
 		items: Array(itemsCount)
 			.fill(undefined)
 			.map(() => {
 				return valueForModelMap({
-					seed: config.seed,
-					map: model.items,
+					faker,
+					map: model.items || {},
 					configs: config.itemsFieldConfigs,
 				});
 			}),

package/src/value/slice.ts

@@ -25,41 +25,37 @@ export type MockSliceValueConfig<
 export const slice = <
 	Model extends prismicT.CustomTypeModelSlice = prismicT.CustomTypeModelSlice,
 >(
-	config: MockSliceValueConfig<Model> = {},
+	config: MockSliceValueConfig<Model>,
 ): ModelValue<Model> => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
-	const model = config.model || modelGen.slice({ seed: config.seed });
+	const model = config.model || modelGen.slice({ faker });
 
-	const sliceType = config.type ?? generateFieldId({ seed: config.seed });
+	const sliceType = config.type ?? generateFieldId({ faker });
 	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
-			? config.itemsCount ??
-			  faker.datatype.number({
-					min: 1,
-					max: 6,
-			  })
+		model.repeat && Object.keys(model.repeat).length > 0
+			? config.itemsCount ?? faker.range(1, 6)
 			: 0;
 
 	return {
 		slice_type: sliceType,
 		slice_label: sliceLabel,
 		primary: valueForModelMap({
-			seed: config.seed,
-			map: model["non-repeat"],
+			faker,
+			map: model["non-repeat"] || {},
 			configs: config.primaryFieldConfigs,
 		}),
 		items: Array(itemsCount)
 			.fill(undefined)
 			.map(() => {
 				return valueForModelMap({
-					seed: config.seed,
-					map: model.repeat,
+					faker,
+					map: model.repeat || {},
 					configs: config.itemsFieldConfigs,
 				});
 			}),