@prismicio/mock 0.0.8 → 0.1.0

package/src/value/sliceZone.ts

@@ -25,36 +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) {
-			const itemsCount =
-				config.itemsCount ??
-				faker.datatype.number({
-					min: 1,
-					max: 6,
-				});
+		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 [choiceType, choiceModel] = faker.random.arrayElement(choices);
+					const choices =
+						(model.config?.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,
+								faker,
 								model: choiceModel,
 								type: choiceType,
 								label: choiceLabel ? choiceLabel.name : null,
@@ -70,7 +67,7 @@ export const sliceZone = <
 
 							if (sharedSliceModel) {
 								return sharedSlice({
-									seed: config.seed,
+									faker,
 									model: sharedSliceModel,
 									primaryFieldConfigs: config.primaryFieldConfigs,
 									itemsFieldConfigs: config.itemsFieldConfigs,
@@ -80,8 +77,7 @@ export const sliceZone = <
 					}
 				})
 				.filter(
-					(slice): slice is prismicT.Slice | prismicT.SharedSlice =>
-						slice !== undefined,
+					(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

@@ -21,23 +21,36 @@ 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);
-
-	// 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 (
-		config.state === "empty"
-			? null
-			: faker.date.between(after, before).toISOString()
-	) as MockTimestampValue<State>;
+	const faker = config.faker || createFaker(config.seed);
+
+	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>;
+	}
 };

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.lorem.words(2));
+	return changeCase.snakeCase(faker.words(faker.range(1, 3)));
 };