@prismicio/mock 0.0.8 → 0.1.0

package/src/model/sharedSlice.ts

@@ -5,7 +5,7 @@ import { createFaker } from "../lib/createFaker";
 
 import { MockModelConfig } from "../types";
 
-type MockSharedSliceModelConfig<
+export type MockSharedSliceModelConfig<
 	Variation extends prismicT.SharedSliceModelVariation,
 > = {
 	id?: string;
@@ -16,12 +16,12 @@ type MockSharedSliceModelConfig<
 export const sharedSlice = <
 	Variation extends prismicT.SharedSliceModelVariation,
 >(
-	config: MockSharedSliceModelConfig<Variation> = {},
+	config: MockSharedSliceModelConfig<Variation>,
 ): prismicT.SharedSliceModel<string, Variation> => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
 	let name: string =
-		config.name || changeCase.capitalCase(faker.company.bsNoun());
+		config.name || changeCase.capitalCase(faker.words(faker.range(1, 2)));
 	let id: string = config.id || changeCase.snakeCase(name);
 
 	if (config.id && !config.name) {
@@ -34,7 +34,7 @@ export const sharedSlice = <
 		type: prismicT.CustomTypeModelSliceType.SharedSlice,
 		id,
 		name,
-		description: faker.lorem.sentence(),
+		description: changeCase.sentenceCase(faker.words(faker.range(5, 10))),
 		variations: config.variations || ([] as Variation[]),
 	};
 };

package/src/model/sharedSliceVariation.ts

@@ -2,6 +2,7 @@ import * as prismicT from "@prismicio/types";
 import * as changeCase from "change-case";
 
 import { createFaker } from "../lib/createFaker";
+import { getMockImageData } from "../lib/getMockImageData";
 
 import { GroupFieldModelMap, MockModelConfig } from "../types";
 
@@ -21,16 +22,12 @@ export const sharedSliceVariation = <
 	PrimaryFields extends GroupFieldModelMap,
 	ItemsFields extends GroupFieldModelMap,
 >(
-	config: MockSharedSliceVariationModelConfig<
-		ID,
-		PrimaryFields,
-		ItemsFields
-	> = {},
+	config: MockSharedSliceVariationModelConfig<ID, PrimaryFields, ItemsFields>,
 ): prismicT.SharedSliceModelVariation<ID, PrimaryFields, ItemsFields> => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
 	let name: string =
-		config.name || changeCase.capitalCase(faker.company.bsNoun());
+		config.name || changeCase.capitalCase(faker.words(faker.range(1, 2)));
 	let id: ID = config.id || (changeCase.snakeCase(name) as ID);
 
 	if (config.id && !config.name) {
@@ -39,13 +36,16 @@ export const sharedSliceVariation = <
 		id = changeCase.snakeCase(config.name) as ID;
 	}
 
+	const imageData = getMockImageData({ faker });
+
 	return {
 		id,
 		name,
-		description: faker.lorem.sentence(),
-		docURL: faker.internet.url(),
-		version: faker.git.shortSha(),
+		description: changeCase.sentenceCase(faker.words(faker.range(5, 10))),
+		docURL: faker.url(),
+		version: faker.hash(7),
 		primary: config.primaryFields || ({} as PrimaryFields),
 		items: config.itemsFields || ({} as ItemsFields),
+		imageUrl: imageData.url,
 	};
 };

package/src/model/slice.ts

@@ -5,7 +5,7 @@ import { createFaker } from "../lib/createFaker";
 
 import { GroupFieldModelMap, MockModelConfig } from "../types";
 
-type MockSliceModelConfig<
+export type MockSliceModelConfig<
 	NonRepeatFields extends GroupFieldModelMap = GroupFieldModelMap,
 	RepeatFields extends GroupFieldModelMap = GroupFieldModelMap,
 > = {
@@ -17,18 +17,18 @@ export const slice = <
 	NonRepeatFields extends GroupFieldModelMap,
 	RepeatFields extends GroupFieldModelMap,
 >(
-	config: MockSliceModelConfig<NonRepeatFields, RepeatFields> = {},
+	config: MockSliceModelConfig<NonRepeatFields, RepeatFields>,
 ): prismicT.CustomTypeModelSlice<NonRepeatFields, RepeatFields> => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
 	return {
 		type: prismicT.CustomTypeModelSliceType.Slice,
-		icon: changeCase.snakeCase(faker.company.bsNoun()),
-		display: faker.datatype.boolean()
+		icon: changeCase.snakeCase(faker.word()),
+		display: faker.boolean()
 			? prismicT.CustomTypeModelSliceDisplay.Grid
 			: prismicT.CustomTypeModelSliceDisplay.List,
-		fieldset: changeCase.capitalCase(faker.lorem.words()),
-		description: faker.lorem.sentence(),
+		fieldset: changeCase.capitalCase(faker.words(2)),
+		description: changeCase.sentenceCase(faker.words(faker.range(5, 10))),
 		repeat: config.repeatFields || ({} as RepeatFields),
 		"non-repeat": config.nonRepeatFields || ({} as NonRepeatFields),
 	};

package/src/model/sliceZone.ts

@@ -2,7 +2,7 @@ import * as prismicT from "@prismicio/types";
 
 import { MockModelConfig } from "../types";
 
-type MockSliceZoneModelConfig<
+export type MockSliceZoneModelConfig<
 	Slices extends Record<
 		string,
 		prismicT.CustomTypeModelSlice | prismicT.CustomTypeModelSharedSlice
@@ -20,10 +20,13 @@ export const sliceZone = <
 		prismicT.CustomTypeModelSlice | prismicT.CustomTypeModelSharedSlice
 	>,
 >(
-	config: MockSliceZoneModelConfig<Slices> = {},
+	config: MockSliceZoneModelConfig<Slices>,
 ): prismicT.CustomTypeModelSliceZoneField<Slices> => {
-	const labels =
-		{} as prismicT.CustomTypeModelSliceZoneField<Slices>["config"]["labels"];
+	const labels = {} as NonNullable<
+		NonNullable<
+			prismicT.CustomTypeModelSliceZoneField<Slices>["config"]
+		>["labels"]
+	>;
 
 	for (const choiceId in config.choices) {
 		const choice = config.choices[choiceId];

package/src/model/timestamp.ts

@@ -8,15 +8,15 @@ import { MockModelConfig } from "../types";
 export type MockTimestampModelConfig = MockModelConfig;
 
 export const timestamp = (
-	config: MockTimestampModelConfig = {},
+	config: MockTimestampModelConfig,
 ): prismicT.CustomTypeModelTimestampField => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
 	return {
 		type: prismicT.CustomTypeModelFieldType.Timestamp,
 		config: {
-			label: changeCase.capitalCase(faker.company.bsNoun()),
-			placeholder: changeCase.sentenceCase(faker.lorem.words(3)),
+			label: changeCase.capitalCase(faker.word()),
+			placeholder: changeCase.sentenceCase(faker.words(3)),
 		},
 	};
 };

package/src/model/title.ts

@@ -8,12 +8,12 @@ import { MockModelConfig } from "../types";
 export type MockTitleModelConfig = MockModelConfig;
 
 export const title = (
-	config: MockTitleModelConfig = {},
+	config: MockTitleModelConfig,
 ): prismicT.CustomTypeModelTitleField => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
-	const single = faker.random
-		.arrayElements([
+	const single = faker
+		.randomElements([
 			"heading1",
 			"heading2",
 			"heading3",
@@ -26,10 +26,10 @@ export const title = (
 	return {
 		type: prismicT.CustomTypeModelFieldType.StructuredText,
 		config: {
-			label: changeCase.capitalCase(faker.company.bsNoun()),
-			placeholder: changeCase.sentenceCase(faker.lorem.words(3)),
+			label: changeCase.capitalCase(faker.word()),
+			placeholder: changeCase.sentenceCase(faker.words(3)),
 			single,
-			allowTargetBlank: faker.datatype.boolean() ? true : undefined,
+			allowTargetBlank: faker.boolean() || undefined,
 		},
 	};
 };

package/src/model/uid.ts

@@ -8,15 +8,15 @@ import { MockModelConfig } from "../types";
 export type MockUIDModelConfig = MockModelConfig;
 
 export const uid = (
-	config: MockUIDModelConfig = {},
+	config: MockUIDModelConfig,
 ): prismicT.CustomTypeModelUIDField => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
 	return {
 		type: prismicT.CustomTypeModelFieldType.UID,
 		config: {
-			label: changeCase.capitalCase(faker.company.bsNoun()),
-			placeholder: changeCase.sentenceCase(faker.lorem.words(3)),
+			label: changeCase.capitalCase(faker.word()),
+			placeholder: changeCase.sentenceCase(faker.words(3)),
 		},
 	};
 };

package/src/types.ts

@@ -1,4 +1,5 @@
 import * as prismicT from "@prismicio/types";
+import { Faker } from "./lib/createFaker";
 
 import * as value from "./value";
 
@@ -27,7 +28,11 @@ export type SetRequired<BaseType, Keys extends keyof BaseType> = Simplify<
 		Required<Pick<BaseType, Keys>>
 >;
 
-export type Seed = string | number | number[];
+export type Seed = string | number;
+
+export type WithoutFakerConfig<T> = {
+	[P in keyof T as P extends "seed" | "faker" ? never : P]: T[P];
+};
 
 export interface MockImageData {
 	url: string;
@@ -35,22 +40,31 @@ export interface MockImageData {
 	height: number;
 }
 
-export interface MockEmbedData {
-	url: string;
-	embed_url: string;
-	html: string;
-	thumbnail_url: string | null;
-	thumbnail_height: number | null;
-	thumbnail_width: number | null;
-}
+export type MockEmbedData = prismicT.AnyOEmbed &
+	prismicT.OEmbedExtra & {
+		embed_url: string;
+		html: string;
+	};
 
-export type MockRestApiConfig = {
-	seed?: Seed;
-};
+export type MockRestApiConfig =
+	| {
+			seed: Seed;
+			faker?: never;
+	  }
+	| {
+			faker: Faker;
+			seed?: never;
+	  };
 
-export type MockModelConfig = {
-	seed?: Seed;
-};
+export type MockModelConfig =
+	| {
+			seed: Seed;
+			faker?: never;
+	  }
+	| {
+			faker: Faker;
+			seed?: never;
+	  };
 
 // TODO: Add to @prismicio/types
 export type PrismicModel =
@@ -66,9 +80,17 @@ export type GroupFieldModelMap = Record<
 >;
 
 export type MockValueConfig<Model extends PrismicModel = PrismicModel> = {
-	seed?: Seed;
 	model?: Model;
-};
+} & (
+	| {
+			seed: Seed;
+			faker?: never;
+	  }
+	| {
+			faker: Faker;
+			seed?: never;
+	  }
+);
 
 export type MockValueStateConfig<
 	State extends prismicT.FieldState = prismicT.FieldState,
@@ -88,7 +110,7 @@ export type MockValueConfigForModel<
 	: Model extends prismicT.CustomTypeModelDateField
 	? value.MockDateValueConfig<Model, State>
 	: Model extends prismicT.CustomTypeModelEmbedField
-	? value.MockEmbedValueConfig<Model, State>
+	? value.MockEmbedValueConfig<Model, prismicT.AnyOEmbed, State>
 	: Model extends prismicT.CustomTypeModelGeoPointField
 	? value.MockGeoPointValueConfig<Model, State>
 	: Model extends prismicT.CustomTypeModelImageField
@@ -124,9 +146,17 @@ type CustomTypeModelStructuredTextField =
 export type MockRichTextValueConfig<
 	Model extends CustomTypeModelStructuredTextField = CustomTypeModelStructuredTextField,
 > = {
-	seed?: Seed;
 	model?: Model;
-};
+} & (
+	| {
+			seed: Seed;
+			faker?: never;
+	  }
+	| {
+			faker: Faker;
+			seed?: never;
+	  }
+);
 
 export type ModelValueMap<
 	T extends Record<string, prismicT.CustomTypeModelField>,
@@ -148,14 +178,18 @@ export type ModelValue<
 	: T extends prismicT.CustomTypeModelSliceZoneField
 	? prismicT.SliceZone<
 			ValueOf<{
-				[P in keyof T["config"]["choices"] as P extends string
+				[P in keyof NonNullable<T["config"]>["choices"] as P extends string
 					? P
-					: never]: T["config"]["choices"][P] extends prismicT.CustomTypeModelSlice
+					: never]: NonNullable<
+					T["config"]
+				>["choices"][P] extends prismicT.CustomTypeModelSlice
 					? CustomTypeModelSliceValue<
-							T["config"]["choices"][P],
+							NonNullable<T["config"]>["choices"][P],
 							P extends string ? P : string
 					  >
-					: T["config"]["choices"][P] extends prismicT.CustomTypeModelSharedSlice
+					: NonNullable<
+							T["config"]
+					  >["choices"][P] extends prismicT.CustomTypeModelSharedSlice
 					? prismicT.SharedSlice<P extends string ? P : string>
 					: never;
 			}>,
@@ -217,27 +251,32 @@ type CustomTypeModelFieldForGroupValue<
 	: T extends prismicT.CustomTypeModelGeoPointField
 	? prismicT.GeoPointField<State>
 	: T extends prismicT.CustomTypeModelIntegrationFieldsField
-	? prismicT.IntegrationFields<unknown, State>
+	? prismicT.IntegrationFields<Record<string, unknown>, State>
 	: never;
 
 type CustomTypeModelGroupFieldValue<
 	T extends prismicT.CustomTypeModelGroupField,
 	State extends prismicT.FieldState = prismicT.FieldState,
-> = prismicT.GroupField<ModelValueMap<T["config"]["fields"]>, State>;
+> = prismicT.GroupField<
+	ModelValueMap<NonNullable<NonNullable<T["config"]>["fields"]>>,
+	State
+>;
 
 type CustomTypeModelSliceValue<
 	T extends prismicT.CustomTypeModelSlice,
 	SliceType = string,
 > = prismicT.Slice<
 	SliceType,
-	ModelValueMap<T["non-repeat"]>,
-	ModelValueMap<T["repeat"]>
+	ModelValueMap<NonNullable<T["non-repeat"]>>,
+	ModelValueMap<NonNullable<T["repeat"]>>
 >;
 
 type SharedSliceModelValue<T extends prismicT.SharedSliceModel> =
 	prismicT.SharedSlice<
 		T["id"],
-		SharedSliceModelVariationValue<IterableElement<T["variations"]>>
+		SharedSliceModelVariationValue<
+			IterableElement<NonNullable<T["variations"]>>
+		>
 	>;
 
 type SharedSliceModelVariationValue<
@@ -246,7 +285,7 @@ type SharedSliceModelVariationValue<
 	string,
 	prismicT.SharedSliceVariation<
 		T["id"],
-		ModelValueMap<T["primary"]>,
-		ModelValueMap<T["items"]>
+		ModelValueMap<NonNullable<T["primary"]>>,
+		ModelValueMap<NonNullable<T["items"]>>
 	>
 >;

package/src/value/boolean.ts

@@ -8,12 +8,10 @@ export type MockBooleanValueConfig<
 	Model extends prismicT.CustomTypeModelBooleanField = prismicT.CustomTypeModelBooleanField,
 > = MockValueConfig<Model>;
 
-export const boolean = <
-	Model extends prismicT.CustomTypeModelBooleanField = prismicT.CustomTypeModelBooleanField,
->(
-	config: MockBooleanValueConfig<Model> = {},
+export const boolean = <Model extends prismicT.CustomTypeModelBooleanField>(
+	config: MockBooleanValueConfig<Model>,
 ): prismicT.BooleanField => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
-	return faker.datatype.boolean();
+	return faker.boolean();
 };

package/src/value/color.ts

@@ -17,11 +17,11 @@ export const color = <
 	Model extends prismicT.CustomTypeModelColorField = prismicT.CustomTypeModelColorField,
 	State extends prismicT.FieldState = "filled",
 >(
-	config: MockColorValueConfig<Model, State> = {},
+	config: MockColorValueConfig<Model, State>,
 ): MockColorValue<State> => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
 	return (
-		config.state === "empty" ? null : faker.internet.color().toUpperCase()
+		config.state === "empty" ? null : faker.hexColor().toUpperCase()
 	) as MockColorValue<State>;
 };

package/src/value/contentRelationship.ts

@@ -5,7 +5,11 @@ import { createFaker } from "../lib/createFaker";
 import { generateCustomTypeId } from "../lib/generateCustomTypeId";
 import { generateTags } from "../lib/generateTags";
 
-import { MockValueStateConfig, MockValueConfig } from "../types";
+import {
+	MockValueStateConfig,
+	MockValueConfig,
+	IterableElement,
+} from "../types";
 
 import * as modelGen from "../model";
 
@@ -26,7 +30,7 @@ type MockContentRelationshipValue<
 	Model extends prismicT.CustomTypeModelContentRelationshipField = prismicT.CustomTypeModelContentRelationshipField,
 	State extends prismicT.FieldState = prismicT.FieldState,
 > = prismicT.RelationField<
-	Model["config"]["customtypes"],
+	IterableElement<NonNullable<Model["config"]>["customtypes"]>,
 	string,
 	never,
 	State
@@ -36,17 +40,16 @@ export const contentRelationship = <
 	Model extends prismicT.CustomTypeModelContentRelationshipField = prismicT.CustomTypeModelContentRelationshipField,
 	State extends prismicT.FieldState = "filled",
 >(
-	config: MockContentRelationshipValueConfig<Model, State> = {},
+	config: MockContentRelationshipValueConfig<Model, State>,
 ): MockContentRelationshipValue<Model, State> => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
 	if (config.state === "empty") {
 		return {
 			link_type: prismicT.LinkType.Document,
 		} as MockContentRelationshipValue<Model, State>;
 	} else {
-		const model =
-			config.model || modelGen.contentRelationship({ seed: config.seed });
+		const model = config.model || modelGen.contentRelationship({ faker });
 
 		const linkableDocuments = config.linkableDocuments
 			? config.linkableDocuments.filter(
@@ -54,16 +57,16 @@ export const contentRelationship = <
 						document,
 					): document is prismicT.PrismicDocument<
 						never,
-						NonNullable<Model["config"]["customtypes"]>[number]
+						NonNullable<NonNullable<Model["config"]>["customtypes"]>[number]
 					> => {
 						let shouldKeep = true;
 
-						if (model.config.customtypes) {
+						if (model.config?.customtypes) {
 							shouldKeep =
 								shouldKeep && model.config.customtypes.includes(document.type);
 						}
 
-						if (model.config.tags) {
+						if (model.config?.tags) {
 							shouldKeep =
 								shouldKeep &&
 								model.config.tags.some((tag) => document.tags.includes(tag));
@@ -74,20 +77,20 @@ export const contentRelationship = <
 			  )
 			: [
 					{
-						...documentGen({ seed: config.seed }),
-						type: model.config.customtypes
-							? faker.random.arrayElement(model.config.customtypes)
-							: generateCustomTypeId({ seed: config.seed }),
-						tags: model.config.tags
-							? faker.random.arrayElements(model.config.tags)
-							: generateTags({ seed: config.seed }),
+						...documentGen({ faker }),
+						type: model.config?.customtypes
+							? faker.randomElement(model.config.customtypes)
+							: generateCustomTypeId({ faker }),
+						tags: model.config?.tags
+							? faker.randomElements(model.config.tags)
+							: generateTags({ faker }),
 					} as prismicT.PrismicDocument<
 						never,
-						NonNullable<Model["config"]["customtypes"]>[number]
+						NonNullable<NonNullable<Model["config"]>["customtypes"]>[number]
 					>,
 			  ];
 
-		const document = faker.random.arrayElement(linkableDocuments);
+		const document = faker.randomElement(linkableDocuments);
 
 		if (!document) {
 			throw new Error("A linkable document could not be found.");