@prismicio/mock 0.0.9 → 0.1.1

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,11 +9,13 @@ 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: "filled",
 	});

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,48 +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.randomElement(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.range(pattern.blockCountMin, 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.randomElement(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

@@ -25,9 +25,9 @@ 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 ||

package/src/value/richText/oList.ts

@@ -25,9 +25,9 @@ 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 ||

package/src/value/richText/paragraph.ts

@@ -22,9 +22,9 @@ 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 ||

package/src/value/richText/preformatted.ts

@@ -22,9 +22,9 @@ 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 ||

package/src/value/select.ts

@@ -14,18 +14,22 @@ 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>;
@@ -33,7 +37,7 @@ export const select = <
 		return (
 			typeof defaultValue === "string" && faker.boolean()
 				? defaultValue
-				: faker.randomElement(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 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,17 +24,16 @@ 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
+		model.items && Object.keys(model.items).length > 0
 			? config.itemsCount ?? faker.range(1, 6)
 			: 0;
 
@@ -44,16 +43,16 @@ export const sharedSliceVariation = <
 		variation: model.id,
 		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,20 +25,20 @@ 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.words(faker.range(1, 2)));
 
 	const itemsCount =
-		Object.keys(model.repeat).length > 0
+		model.repeat && Object.keys(model.repeat).length > 0
 			? config.itemsCount ?? faker.range(1, 6)
 			: 0;
 
@@ -46,16 +46,16 @@ export const slice = <
 		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,
 				});
 			}),

package/src/value/sliceZone.ts

@@ -25,31 +25,33 @@ export const sliceZone = <
 	Model extends prismicT.CustomTypeModelSliceZoneField = prismicT.CustomTypeModelSliceZoneField,
 	State extends prismicT.FieldState = prismicT.FieldState,
 >(
-	config: MockSliceZoneValueConfig<Model, State> = {},
+	config: MockSliceZoneValueConfig<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.sliceZone({ seed: config.seed });
+		const model = config.model || modelGen.sliceZone({ faker });
 
-		if (Object.keys(model.config.choices).length > 0) {
+		if (model.config?.choices && 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 choices =
+						(model.config?.choices && Object.entries(model.config.choices)) ||
+						[];
 					const [choiceType, choiceModel] = faker.randomElement(choices);
 
-					const choiceLabels = model.config.labels[choiceType] || [];
+					const choiceLabels = model.config?.labels?.[choiceType] || [];
 					const choiceLabel = faker.randomElement(choiceLabels);
 
 					switch (choiceModel.type) {
 						case prismicT.CustomTypeModelSliceType.Slice: {
 							return slice({
-								seed: config.seed,
+								faker,
 								model: choiceModel,
 								type: choiceType,
 								label: choiceLabel ? choiceLabel.name : null,
@@ -65,7 +67,7 @@ export const sliceZone = <
 
 							if (sharedSliceModel) {
 								return sharedSlice({
-									seed: config.seed,
+									faker,
 									model: sharedSliceModel,
 									primaryFieldConfigs: config.primaryFieldConfigs,
 									itemsFieldConfigs: config.itemsFieldConfigs,

package/src/value/timestamp.ts

@@ -21,9 +21,9 @@ export const timestamp = <
 	Model extends prismicT.CustomTypeModelTimestampField = prismicT.CustomTypeModelTimestampField,
 	State extends prismicT.FieldState = "filled",
 >(
-	config: MockTimestampValueConfig<Model, State> = {},
+	config: MockTimestampValueConfig<Model, State>,
 ): MockTimestampValue<State> => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
 	if (config.state === "empty") {
 		return null as MockTimestampValue<State>;

package/src/value/title.ts

@@ -1,5 +1,7 @@
 import * as prismicT from "@prismicio/types";
 
+import { createFaker } from "../lib/createFaker";
+
 import { MockValueConfig, MockValueStateConfig } from "../types";
 
 import { heading, MockRichTextHeadingValueConfig } from "./richText/heading";
@@ -18,17 +20,19 @@ export type MockTitleValue<
 
 export const title = <
 	Model extends prismicT.CustomTypeModelTitleField = prismicT.CustomTypeModelTitleField,
-	State extends prismicT.FieldState = prismicT.FieldState,
+	State extends prismicT.FieldState = "filled",
 >(
-	config: MockTitleValueConfig<Model, State> = {},
+	config: MockTitleValueConfig<Model, State>,
 ): MockTitleValue<State> => {
+	const faker = config.faker || createFaker(config.seed);
+
 	if (config.state === "empty") {
 		return [] as MockTitleValue<State>;
 	} else {
 		return [
 			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 			heading({
-				seed: config.seed,
+				faker,
 				model: config.model,
 				pattern: config.pattern,
 			})!,

package/src/value/uid.ts

@@ -9,10 +9,12 @@ export type MockUIDValueConfig<
 	Model extends prismicT.CustomTypeModelUIDField = prismicT.CustomTypeModelUIDField,
 > = MockValueConfig<Model>;
 
-export const uid = (
-	config: MockUIDValueConfig = {},
+export const uid = <
+	Model extends prismicT.CustomTypeModelUIDField = prismicT.CustomTypeModelUIDField,
+>(
+	config: MockUIDValueConfig<Model>,
 ): NonNullable<prismicT.PrismicDocument["uid"]> => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
 	return changeCase.snakeCase(faker.words(faker.range(1, 3)));
 };