@prismicio/mock 0.0.4 → 0.0.8

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,13 +31,6 @@ 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
@@ -65,9 +39,10 @@ export const slice = <
 
 	const itemsCount =
 		Object.keys(model.repeat).length > 0
-			? faker.datatype.number({
-					min: pattern.minItems,
-					max: pattern.maxItems,
+			? config.itemsCount ??
+			  faker.datatype.number({
+					min: 1,
+					max: 6,
 			  })
 			: 0;
 

package/src/value/sliceZone.ts

@@ -3,97 +3,88 @@ 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.datatype.number({
+					min: 1,
+					max: 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.random.arrayElement(choices);
 
-			const choiceLabels = model.config.labels[choiceType] || [];
-			const choiceLabel = faker.random.arrayElement(choiceLabels);
+					const choiceLabels = model.config.labels[choiceType] || [];
+					const choiceLabel = faker.random.arrayElement(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 prismicT.Slice | prismicT.SharedSlice =>
+						slice !== undefined,
+				) as ModelValue<Model, State>;
+		} else {
+			return [] as unknown as ModelValue<Model, State>;
+		}
+	}
 };

package/src/value/timestamp.ts

@@ -2,18 +2,27 @@ 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`
@@ -26,5 +35,9 @@ export const timestamp = (
 		config.before ||
 		faker.date.future(20, new Date("2021-03-07")).toISOString().split("T")[0];
 
-	return faker.date.between(after, before).toISOString();
+	return (
+		config.state === "empty"
+			? null
+			: faker.date.between(after, before).toISOString()
+	) as MockTimestampValue<State>;
 };

package/src/value/title.ts

@@ -1,24 +1,37 @@
 import * as prismicT from "@prismicio/types";
 
-import { MockValueConfig } from "../types";
+import { MockValueConfig, MockValueStateConfig } from "../types";
 
 import { heading, MockRichTextHeadingValueConfig } from "./richText/heading";
 
 export type MockTitleValueConfig<
 	Model extends prismicT.CustomTypeModelTitleField = prismicT.CustomTypeModelTitleField,
+	State extends prismicT.FieldState = prismicT.FieldState,
 > = {
 	pattern?: MockRichTextHeadingValueConfig["pattern"];
-} & MockValueConfig<Model>;
+} & MockValueConfig<Model> &
+	MockValueStateConfig<State>;
 
-export const title = (
-	config: MockTitleValueConfig = {},
-): prismicT.TitleField => {
-	return [
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		heading({
-			seed: config.seed,
-			model: config.model,
-			pattern: config.pattern,
-		})!,
-	];
+export type MockTitleValue<
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = prismicT.TitleField<State>;
+
+export const title = <
+	Model extends prismicT.CustomTypeModelTitleField = prismicT.CustomTypeModelTitleField,
+	State extends prismicT.FieldState = prismicT.FieldState,
+>(
+	config: MockTitleValueConfig<Model, State> = {},
+): MockTitleValue<State> => {
+	if (config.state === "empty") {
+		return [] as MockTitleValue<State>;
+	} else {
+		return [
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			heading({
+				seed: config.seed,
+				model: config.model,
+				pattern: config.pattern,
+			})!,
+		] as MockTitleValue<State>;
+	}
 };

package/src/value/uid.ts

@@ -11,7 +11,7 @@ export type MockUIDValueConfig<
 
 export const uid = (
 	config: MockUIDValueConfig = {},
-): prismicT.PrismicDocument["uid"] => {
+): NonNullable<prismicT.PrismicDocument["uid"]> => {
 	const faker = createFaker(config.seed);
 
 	return changeCase.snakeCase(faker.lorem.words(2));