@prismicio/mock 0.0.6 → 0.0.7

package/src/model/customType.ts

@@ -1,74 +1,75 @@
 import * as prismicT from "@prismicio/types";
 import * as changeCase from "change-case";
 
-import {
-	buildMockGroupFieldMap,
-	BuildMockGroupFieldMapConfig,
-} from "../lib/buildMockGroupFieldMap";
 import { createFaker } from "../lib/createFaker";
-import { generateCustomTypeId } from "../lib/generateCustomTypeId";
-import { generateFieldId } from "../lib/generateFieldId";
 
 import { MockModelConfig } from "../types";
 
-import { uid } from "./uid";
-import { sliceZone } from "./sliceZone";
-
-type MockCustomTypeModelConfig = {
-	tabsCount?: number;
-	withUID?: boolean;
-	configs?: BuildMockGroupFieldMapConfig["configs"];
+type MockCustomTypeModelConfig<
+	Definition extends
+		| prismicT.CustomTypeModelTab
+		| prismicT.CustomTypeModelDefinition =
+		| prismicT.CustomTypeModelTab
+		| prismicT.CustomTypeModelDefinition,
+> = {
+	id?: string;
+	label?: string;
+	status?: boolean;
+	repeatable?: boolean;
 } & (
 	| {
-			withSliceZones?: false;
+			fields?: Definition;
+			tabs?: never;
 	  }
 	| {
-			withSliceZones: true;
-			withSharedSlices?: boolean;
+			tabs?: Definition;
+			fields?: never;
 	  }
 ) &
 	MockModelConfig;
 
-export const customType = (
-	config: MockCustomTypeModelConfig = {},
-): prismicT.CustomTypeModel => {
-	const faker = createFaker(config.seed);
-
-	const tabsCount =
-		config.tabsCount ?? faker.datatype.number({ min: 1, max: 3 });
-
-	const json: prismicT.CustomTypeModelDefinition = {};
-	for (let i = 0; i < tabsCount; i++) {
-		const tabName = changeCase.capitalCase(faker.lorem.word());
-		const tabFields: prismicT.CustomTypeModelTab = buildMockGroupFieldMap({
-			seed: config.seed,
-			configs: config.configs,
-		});
+type MockCustomTypeModel<
+	Definition extends
+		| prismicT.CustomTypeModelTab
+		| prismicT.CustomTypeModelDefinition,
+> = Definition extends prismicT.CustomTypeModelTab
+	? prismicT.CustomTypeModel<string, Record<"Main", Definition>>
+	: Definition extends prismicT.CustomTypeModelDefinition
+	? prismicT.CustomTypeModel<string, Definition>
+	: never;
 
-		if (i === 0 && config.withUID) {
-			const fieldId = generateFieldId({ seed: config.seed });
+export const customType = <
+	Definition extends
+		| prismicT.CustomTypeModelTab
+		| prismicT.CustomTypeModelDefinition,
+>(
+	config: MockCustomTypeModelConfig<Definition> = {},
+): MockCustomTypeModel<Definition> => {
+	const faker = createFaker(config.seed);
 
-			tabFields[fieldId] = uid();
-		}
+	let label: string =
+		config.label || changeCase.capitalCase(faker.company.bsNoun());
+	let id: string = config.id || changeCase.snakeCase(label);
 
-		if (config.withSliceZones) {
-			const sliceZoneId = generateFieldId({ seed: config.seed });
+	if (config.id && !config.label) {
+		label = changeCase.capitalCase(config.id);
+	} else if (config.label && !config.label) {
+		id = changeCase.snakeCase(config.label);
+	}
 
-			tabFields[sliceZoneId] = sliceZone({
-				withSharedSlices: config.withSharedSlices,
-			});
-		}
+	let json = {} as MockCustomTypeModel<Definition>["json"];
 
-		json[tabName] = tabFields;
+	if ("fields" in config && config.fields) {
+		json = { Main: config.fields } as typeof json;
+	} else if ("tabs" in config && config.tabs) {
+		json = config.tabs as typeof json;
 	}
 
-	const id = generateCustomTypeId({ seed: config.seed });
-
 	return {
 		id,
-		label: changeCase.capitalCase(id),
-		status: faker.datatype.boolean(),
-		repeatable: faker.datatype.boolean(),
+		label,
+		status: config.status ?? faker.datatype.boolean(),
+		repeatable: config.repeatable ?? faker.datatype.boolean(),
 		json,
-	};
+	} as MockCustomTypeModel<Definition>;
 };

package/src/model/group.ts

@@ -1,31 +1,24 @@
 import * as prismicT from "@prismicio/types";
 import * as changeCase from "change-case";
 
-import {
-	buildMockGroupFieldMap,
-	BuildMockGroupFieldMapConfig,
-} from "../lib/buildMockGroupFieldMap";
 import { createFaker } from "../lib/createFaker";
 
-import { MockModelConfig } from "../types";
+import { GroupFieldModelMap, MockModelConfig } from "../types";
 
-type MockGroupModelConfig = BuildMockGroupFieldMapConfig & MockModelConfig;
+type MockGroupModelConfig<Fields extends GroupFieldModelMap> = {
+	fields?: Fields;
+} & MockModelConfig;
 
-export const group = (
-	config: MockGroupModelConfig = {},
-): prismicT.CustomTypeModelGroupField => {
+export const group = <Fields extends GroupFieldModelMap>(
+	config: MockGroupModelConfig<Fields> = {},
+): prismicT.CustomTypeModelGroupField<Fields> => {
 	const faker = createFaker(config.seed);
 
-	const fields = buildMockGroupFieldMap({
-		seed: config.seed,
-		configs: config.configs,
-	});
-
 	return {
 		type: prismicT.CustomTypeModelFieldType.Group,
 		config: {
 			label: changeCase.capitalCase(faker.company.bsNoun()),
-			fields,
+			fields: config.fields || ({} as Fields),
 		},
 	};
 };

package/src/model/image.ts

@@ -5,17 +5,23 @@ import { createFaker } from "../lib/createFaker";
 
 import { MockModelConfig } from "../types";
 
-type MockImageModelConfig = {
+type MockImageModelConfig<ThumbnailNames extends string = string> = {
 	withConstraint?: boolean;
-	thumbnailsCount?: number;
+	thumbnailNames?: readonly ThumbnailNames[];
 } & MockModelConfig;
 
-export const image = (
-	config: MockImageModelConfig = {},
-): prismicT.CustomTypeModelImageField => {
+export const image = <ThumbnailNames extends string = string>(
+	config: MockImageModelConfig<ThumbnailNames> = {},
+): prismicT.CustomTypeModelImageField<ThumbnailNames> => {
 	const faker = createFaker(config.seed);
 
-	const thumbnailsCount = config.thumbnailsCount ?? faker.datatype.number(3);
+	const thumbnails = (config.thumbnailNames || []).map((name) => {
+		return {
+			name,
+			width: faker.datatype.number({ min: 500, max: 2000 }),
+			height: faker.datatype.number({ min: 500, max: 2000 }),
+		};
+	});
 
 	return {
 		type: prismicT.CustomTypeModelFieldType.Image,
@@ -29,13 +35,7 @@ export const image = (
 					? faker.datatype.number({ min: 500, max: 2000 })
 					: null,
 			},
-			thumbnails: Array(thumbnailsCount)
-				.fill(undefined)
-				.map(() => ({
-					name: changeCase.pascalCase(faker.company.bsNoun()),
-					width: faker.datatype.number({ min: 500, max: 2000 }),
-					height: faker.datatype.number({ min: 500, max: 2000 }),
-				})),
+			thumbnails,
 		},
 	};
 };

package/src/model/index.ts

@@ -22,3 +22,5 @@ export { sliceZone } from "./sliceZone";
 export { timestamp } from "./timestamp";
 export { title } from "./title";
 export { uid } from "./uid";
+
+export { buildMockGroupFieldMap } from "./buildMockGroupFieldMap";

package/src/model/select.ts

@@ -5,31 +5,26 @@ import { createFaker } from "../lib/createFaker";
 
 import { MockModelConfig } from "../types";
 
-type MockSelectModelConfig = {
-	optionsCount?: number;
-	withDefaultValue?: boolean;
+type MockSelectModelConfig<
+	Option extends string = string,
+	DefaultOption extends Option = Option,
+> = {
+	options?: Option[];
+	defaultValue?: DefaultOption;
 } & MockModelConfig;
 
-export const select = (
-	config: MockSelectModelConfig = {},
-): prismicT.CustomTypeModelSelectField => {
+export const select = <Option extends string, DefaultOption extends Option>(
+	config: MockSelectModelConfig<Option, DefaultOption> = {},
+): prismicT.CustomTypeModelSelectField<Option, DefaultOption> => {
 	const faker = createFaker(config.seed);
 
-	const optionsCount =
-		config.optionsCount ?? faker.datatype.number({ min: 1, max: 5 });
-	const options = Array(optionsCount)
-		.fill(undefined)
-		.map(() => changeCase.capitalCase(faker.company.bsBuzz()));
-
 	return {
 		type: prismicT.CustomTypeModelFieldType.Select,
 		config: {
 			label: changeCase.capitalCase(faker.company.bsNoun()),
 			placeholder: changeCase.sentenceCase(faker.lorem.words(3)),
-			options,
-			default_value: config.withDefaultValue
-				? faker.random.arrayElement(options)
-				: undefined,
+			options: config.options || [],
+			default_value: config.defaultValue || undefined,
 		},
 	};
 };

package/src/model/sharedSlice.ts

@@ -5,28 +5,13 @@ import { createFaker } from "../lib/createFaker";
 
 import { MockModelConfig } from "../types";
 
-import {
-	MockSharedSliceVariationModelConfig,
-	sharedSliceVariation,
-} from "./sharedSliceVariation";
-
 type MockSharedSliceModelConfig<
 	Variation extends prismicT.SharedSliceModelVariation,
-> = (
-	| {
-			variations?: Variation[];
-			variationsCount?: never;
-	  }
-	| {
-			variations?: never;
-			variationsCount?: number;
-	  }
-) &
-	Pick<
-		MockSharedSliceVariationModelConfig,
-		"itemsFieldConfig" | "primaryFieldConfig"
-	> &
-	MockModelConfig;
+> = {
+	id?: string;
+	name?: string;
+	variations?: Variation[];
+} & MockModelConfig;
 
 export const sharedSlice = <
 	Variation extends prismicT.SharedSliceModelVariation,
@@ -35,33 +20,21 @@ export const sharedSlice = <
 ): prismicT.SharedSliceModel<string, Variation> => {
 	const faker = createFaker(config.seed);
 
-	const name = changeCase.capitalCase(faker.company.bsNoun());
-
-	let variations: Variation[] = [];
-
-	if ("variations" in config) {
-		variations = config.variations || [];
-	} else {
-		const variationsCount =
-			config.variationsCount ?? faker.datatype.number({ min: 1, max: 3 });
+	let name: string =
+		config.name || changeCase.capitalCase(faker.company.bsNoun());
+	let id: string = config.id || changeCase.snakeCase(name);
 
-		variations = Array(variationsCount)
-			.fill(undefined)
-			.map(
-				() =>
-					sharedSliceVariation({
-						seed: config.seed,
-						itemsFieldConfig: config.itemsFieldConfig,
-						primaryFieldConfig: config.primaryFieldConfig,
-					}) as Variation,
-			);
+	if (config.id && !config.name) {
+		name = changeCase.pascalCase(config.id);
+	} else if (config.name && !config.name) {
+		id = changeCase.snakeCase(config.name);
 	}
 
 	return {
 		type: prismicT.CustomTypeModelSliceType.SharedSlice,
-		id: changeCase.snakeCase(name),
+		id,
 		name,
 		description: faker.lorem.sentence(),
-		variations,
+		variations: config.variations || ([] as Variation[]),
 	};
 };

package/src/model/sharedSliceVariation.ts

@@ -2,38 +2,50 @@ import * as prismicT from "@prismicio/types";
 import * as changeCase from "change-case";
 
 import { createFaker } from "../lib/createFaker";
-import {
-	buildMockGroupFieldMap,
-	BuildMockGroupFieldMapConfig,
-} from "../lib/buildMockGroupFieldMap";
 
-import { MockModelConfig } from "../types";
+import { GroupFieldModelMap, MockModelConfig } from "../types";
 
-export type MockSharedSliceVariationModelConfig = {
-	primaryFieldConfig?: BuildMockGroupFieldMapConfig;
-	itemsFieldConfig?: BuildMockGroupFieldMapConfig;
+export type MockSharedSliceVariationModelConfig<
+	ID extends string = string,
+	PrimaryFields extends GroupFieldModelMap = GroupFieldModelMap,
+	ItemsFields extends GroupFieldModelMap = GroupFieldModelMap,
+> = {
+	id?: ID;
+	name?: string;
+	primaryFields?: PrimaryFields;
+	itemsFields?: ItemsFields;
 } & MockModelConfig;
 
-export const sharedSliceVariation = (
-	config: MockSharedSliceVariationModelConfig = {},
-): prismicT.SharedSliceModelVariation => {
+export const sharedSliceVariation = <
+	ID extends string,
+	PrimaryFields extends GroupFieldModelMap,
+	ItemsFields extends GroupFieldModelMap,
+>(
+	config: MockSharedSliceVariationModelConfig<
+		ID,
+		PrimaryFields,
+		ItemsFields
+	> = {},
+): prismicT.SharedSliceModelVariation<ID, PrimaryFields, ItemsFields> => {
 	const faker = createFaker(config.seed);
 
-	const name = changeCase.capitalCase(faker.company.bsNoun());
+	let name: string =
+		config.name || changeCase.capitalCase(faker.company.bsNoun());
+	let id: ID = config.id || (changeCase.snakeCase(name) as ID);
+
+	if (config.id && !config.name) {
+		name = changeCase.pascalCase(config.id);
+	} else if (config.name && !config.name) {
+		id = changeCase.snakeCase(config.name) as ID;
+	}
 
 	return {
-		id: changeCase.snakeCase(name),
+		id,
 		name,
 		description: faker.lorem.sentence(),
 		docURL: faker.internet.url(),
 		version: faker.git.shortSha(),
-		primary: buildMockGroupFieldMap({
-			seed: config.primaryFieldConfig?.seed ?? config.seed,
-			configs: config.primaryFieldConfig?.configs,
-		}),
-		items: buildMockGroupFieldMap({
-			seed: config.itemsFieldConfig?.seed ?? config.seed,
-			configs: config.itemsFieldConfig?.configs,
-		}),
+		primary: config.primaryFields || ({} as PrimaryFields),
+		items: config.itemsFields || ({} as ItemsFields),
 	};
 };

package/src/model/slice.ts

@@ -2,21 +2,23 @@ import * as prismicT from "@prismicio/types";
 import * as changeCase from "change-case";
 
 import { createFaker } from "../lib/createFaker";
-import {
-	buildMockGroupFieldMap,
-	BuildMockGroupFieldMapConfig,
-} from "../lib/buildMockGroupFieldMap";
 
-import { MockModelConfig } from "../types";
+import { GroupFieldModelMap, MockModelConfig } from "../types";
 
-type MockSliceModelConfig = {
-	repeatFieldConfig?: BuildMockGroupFieldMapConfig;
-	nonRepeatFieldConfig?: BuildMockGroupFieldMapConfig;
+type MockSliceModelConfig<
+	NonRepeatFields extends GroupFieldModelMap = GroupFieldModelMap,
+	RepeatFields extends GroupFieldModelMap = GroupFieldModelMap,
+> = {
+	nonRepeatFields?: NonRepeatFields;
+	repeatFields?: RepeatFields;
 } & MockModelConfig;
 
-export const slice = (
-	config: MockSliceModelConfig = {},
-): prismicT.CustomTypeModelSlice => {
+export const slice = <
+	NonRepeatFields extends GroupFieldModelMap,
+	RepeatFields extends GroupFieldModelMap,
+>(
+	config: MockSliceModelConfig<NonRepeatFields, RepeatFields> = {},
+): prismicT.CustomTypeModelSlice<NonRepeatFields, RepeatFields> => {
 	const faker = createFaker(config.seed);
 
 	return {
@@ -27,13 +29,7 @@ export const slice = (
 			: prismicT.CustomTypeModelSliceDisplay.List,
 		fieldset: changeCase.capitalCase(faker.lorem.words()),
 		description: faker.lorem.sentence(),
-		repeat: buildMockGroupFieldMap({
-			seed: config.repeatFieldConfig?.seed ?? config.seed,
-			configs: config.repeatFieldConfig?.configs,
-		}),
-		"non-repeat": buildMockGroupFieldMap({
-			seed: config.nonRepeatFieldConfig?.seed ?? config.seed,
-			configs: config.nonRepeatFieldConfig?.configs,
-		}),
+		repeat: config.repeatFields || ({} as RepeatFields),
+		"non-repeat": config.nonRepeatFields || ({} as NonRepeatFields),
 	};
 };

package/src/model/sliceZone.ts

@@ -1,71 +1,35 @@
 import * as prismicT from "@prismicio/types";
-import * as changeCase from "change-case";
-
-import { createFaker } from "../lib/createFaker";
-import { generateFieldId } from "../lib/generateFieldId";
 
 import { MockModelConfig } from "../types";
 
-import { sharedSliceChoice } from "./sharedSliceChoice";
-import { slice } from "./slice";
-
-type MockSliceZoneModelConfig = (
-	| {
-			choices?: Record<
-				string,
-				prismicT.CustomTypeModelSlice | prismicT.CustomTypeModelSharedSlice
-			>;
-			choicesCount?: never;
-			withSharedSlices?: never;
-	  }
-	| {
-			choices?: never;
-			choicesCount?: number;
-			withSharedSlices?: boolean;
-	  }
-) &
-	MockModelConfig;
-
-export const sliceZone = (
-	config: MockSliceZoneModelConfig = {},
-): prismicT.CustomTypeModelSliceZoneField => {
-	const faker = createFaker(config.seed);
-
-	let choices: Record<
+type MockSliceZoneModelConfig<
+	Slices extends Record<
 		string,
 		prismicT.CustomTypeModelSlice | prismicT.CustomTypeModelSharedSlice
-	> = {};
-
-	if ("choices" in config) {
-		choices = config.choices || {};
-	} else {
-		const choicesCount =
-			config.choicesCount ?? faker.datatype.number({ min: 2, max: 6 });
-
-		for (let i = 0; i < choicesCount; i++) {
-			const choiceId = generateFieldId({ seed: config.seed });
+	> = Record<
+		string,
+		prismicT.CustomTypeModelSlice | prismicT.CustomTypeModelSharedSlice
+	>,
+> = {
+	choices?: Slices;
+} & MockModelConfig;
 
-			choices[choiceId] = config.withSharedSlices
-				? sharedSliceChoice()
-				: slice({ seed: config.seed });
-		}
-	}
+export const sliceZone = <
+	Slices extends Record<
+		string,
+		prismicT.CustomTypeModelSlice | prismicT.CustomTypeModelSharedSlice
+	>,
+>(
+	config: MockSliceZoneModelConfig<Slices> = {},
+): prismicT.CustomTypeModelSliceZoneField<Slices> => {
+	const labels =
+		{} as prismicT.CustomTypeModelSliceZoneField<Slices>["config"]["labels"];
 
-	const labels: Record<string, prismicT.CustomTypeModelSliceLabel[]> = {};
-	for (const choiceId in choices) {
-		const choice = choices[choiceId];
+	for (const choiceId in config.choices) {
+		const choice = config.choices[choiceId];
 
 		if (choice.type === prismicT.CustomTypeModelSliceType.Slice) {
-			const labelsCount = faker.datatype.number({ min: 0, max: 3 });
-
-			labels[choiceId] = Array(labelsCount)
-				.fill(undefined)
-				.map(() => ({
-					name: changeCase.capitalCase(faker.company.bsNoun()),
-					display: faker.datatype.boolean()
-						? prismicT.CustomTypeModelSliceDisplay.Grid
-						: prismicT.CustomTypeModelSliceDisplay.List,
-				}));
+			labels[choiceId as unknown as keyof typeof labels] = [];
 		}
 	}
 
@@ -74,7 +38,7 @@ export const sliceZone = (
 		fieldset: "Slice zone",
 		config: {
 			labels,
-			choices,
+			choices: config.choices || ({} as Slices),
 		},
 	};
 };

package/src/types.ts

@@ -10,10 +10,8 @@ export type IterableElement<TargetIterable> = TargetIterable extends Iterable<
 	? ElementType
 	: never;
 
-export type ValueOf<
-	ObjectType,
-	ValueType extends keyof ObjectType = keyof ObjectType,
-> = ObjectType[ValueType];
+export type ValueOf<ObjectType extends Record<string, unknown>> =
+	ObjectType[string];
 
 type Simplify<T> = { [KeyType in keyof T]: T[KeyType] };
 type Except<ObjectType, KeysType extends keyof ObjectType> = Pick<
@@ -60,11 +58,22 @@ export type PrismicModel =
 	| prismicT.SharedSliceModel
 	| prismicT.SharedSliceModelVariation;
 
+export type GroupFieldModelMap = Record<
+	string,
+	prismicT.CustomTypeModelFieldForGroup
+>;
+
 export type MockValueConfig<Model extends PrismicModel = PrismicModel> = {
 	seed?: Seed;
 	model?: Model;
 };
 
+export type MockValueStateConfig<
+	State extends prismicT.FieldState = prismicT.FieldState,
+> = {
+	state?: State;
+};
+
 export type MockValueConfigForModel<Model extends PrismicModel> =
 	Model extends prismicT.CustomTypeModelBooleanField
 		? value.MockBooleanValueConfig
@@ -127,7 +136,17 @@ export type ModelValue<T extends PrismicModel> =
 		: T extends prismicT.CustomTypeModelGroupField
 		? CustomTypeModelGroupFieldValue<T>
 		: T extends prismicT.CustomTypeModelSliceZoneField
-		? prismicT.SliceZone
+		? prismicT.SliceZone<
+				ValueOf<{
+					[P in keyof T["config"]["choices"] as P extends string
+						? P
+						: never]: T["config"]["choices"][P] extends prismicT.CustomTypeModelSlice
+						? CustomTypeModelSliceValue<T["config"]["choices"][P], P>
+						: T["config"]["choices"][P] extends prismicT.CustomTypeModelSharedSlice
+						? prismicT.SharedSlice<P>
+						: never;
+				}>
+		  >
 		: T extends prismicT.CustomTypeModelSlice
 		? CustomTypeModelSliceValue<T>
 		: T extends prismicT.CustomTypeModelSharedSlice
@@ -140,7 +159,15 @@ export type ModelValue<T extends PrismicModel> =
 		: never;
 
 type CustomTypeModelValue<T extends prismicT.CustomTypeModel> =
-	prismicT.PrismicDocument<ModelValueMap<ValueOf<T["json"]>>>;
+	prismicT.PrismicDocument<
+		ModelValueMap<{
+			[P in keyof ValueOf<T["json"]> as ValueOf<
+				T["json"]
+			>[P]["type"] extends typeof prismicT.CustomTypeModelFieldType.UID
+				? never
+				: P]: ValueOf<T["json"]>[P];
+		}>
+	>;
 
 type CustomTypeModelFieldForGroupValue<
 	T extends prismicT.CustomTypeModelFieldForGroup,
@@ -182,12 +209,14 @@ type CustomTypeModelGroupFieldValue<
 	T extends prismicT.CustomTypeModelGroupField,
 > = prismicT.GroupField<ModelValueMap<T["config"]["fields"]>>;
 
-type CustomTypeModelSliceValue<T extends prismicT.CustomTypeModelSlice> =
-	prismicT.Slice<
-		string,
-		ModelValueMap<T["non-repeat"]>,
-		ModelValueMap<T["repeat"]>
-	>;
+type CustomTypeModelSliceValue<
+	T extends prismicT.CustomTypeModelSlice,
+	SliceType = string,
+> = prismicT.Slice<
+	SliceType,
+	ModelValueMap<T["non-repeat"]>,
+	ModelValueMap<T["repeat"]>
+>;
 
 type SharedSliceModelValue<T extends prismicT.SharedSliceModel> =
 	prismicT.SharedSlice<