@prismicio/mock 0.7.0 → 0.7.1-canary.b078d42

package/src/value/createValueMockFactory.ts

@@ -1,263 +1,255 @@
-import * as prismic from "@prismicio/client";
+import type * as prismic from "@prismicio/client"
 
-import { createFaker, Faker } from "../lib/createFaker";
-
-import { Seed, WithoutFakerConfig } from "../types";
-
-import { boolean, MockBooleanValueConfig } from "./boolean";
-import { color, MockColorValueConfig } from "./color";
+import { createFaker, type Faker } from "../lib/createFaker"
+import type { ModelValue, Seed, WithoutFakerConfig } from "../types"
+import { boolean, type MockBooleanValueConfig } from "./boolean"
+import { color, type MockColorValue, type MockColorValueConfig } from "./color"
 import {
 	contentRelationship,
-	MockContentRelationshipValueConfig,
-} from "./contentRelationship";
-import { customType, MockCustomTypeValueConfig } from "./customType";
-import { date, MockDateValueConfig } from "./date";
-import { document, MockDocumentValueConfig } from "./document";
-import { embed, MockEmbedValueConfig } from "./embed";
-import { geoPoint, MockGeoPointValueConfig } from "./geoPoint";
-import { group, MockGroupValueConfig } from "./group";
-import { image, MockImageValue, MockImageValueConfig } from "./image";
-import { integration, MockIntegrationFieldValueConfig } from "./integration";
-import { keyText, MockKeyTextValueConfig } from "./keyText";
-import { link, MockLinkValueConfig } from "./link";
-import { linkToMedia, MockLinkToMediaValueConfig } from "./linkToMedia";
-import { number, MockNumberValueConfig } from "./number";
-import { richText, MockRichTextValueConfig } from "./richText";
-import { select, MockSelectValueConfig } from "./select";
-import { sharedSlice, MockSharedSliceValueConfig } from "./sharedSlice";
+	type MockContentRelationshipValue,
+	type MockContentRelationshipValueConfig,
+} from "./contentRelationship"
+import { customType, type MockCustomTypeValueConfig } from "./customType"
+import { date, type MockDateValue, type MockDateValueConfig } from "./date"
+import { document, type MockDocumentValueConfig } from "./document"
+import { embed, type MockEmbedValue, type MockEmbedValueConfig } from "./embed"
+import { geoPoint, type MockGeoPointValue, type MockGeoPointValueConfig } from "./geoPoint"
+import { group, type MockGroupValueConfig } from "./group"
+import { image, type MockImageValue, type MockImageValueConfig } from "./image"
+import {
+	integration,
+	type MockIntegrationFieldValue,
+	type MockIntegrationFieldValueConfig,
+} from "./integration"
+import { keyText, type MockKeyTextValue, type MockKeyTextValueConfig } from "./keyText"
+import { link, type MockLinkValue, type MockLinkValueConfig } from "./link"
+import {
+	linkToMedia,
+	type MockLinkToMediaValue,
+	type MockLinkToMediaValueConfig,
+} from "./linkToMedia"
+import { number, type MockNumberValue, type MockNumberValueConfig } from "./number"
+import { richText, type MockRichTextValue, type MockRichTextValueConfig } from "./richText"
+import { select, type MockSelectValue, type MockSelectValueConfig } from "./select"
+import { sharedSlice, type MockSharedSliceValueConfig } from "./sharedSlice"
 import {
 	sharedSliceVariation,
-	MockSharedSliceVariationValueConfig,
-} from "./sharedSliceVariation";
-import { slice, MockSliceValueConfig } from "./slice";
-import { sliceZone, MockSliceZoneValueConfig } from "./sliceZone";
-import { timestamp, MockTimestampValueConfig } from "./timestamp";
-import { title, MockTitleValueConfig } from "./title";
-import { uid, MockUIDValueConfig } from "./uid";
-import { MockTableValueConfig, table } from "./table";
+	type MockSharedSliceVariationValueConfig,
+} from "./sharedSliceVariation"
+import { slice, type MockSliceValueConfig } from "./slice"
+import { sliceZone, type MockSliceZoneValueConfig } from "./sliceZone"
+import { table, type MockTableValue, type MockTableValueConfig } from "./table"
+import { timestamp, type MockTimestampValue, type MockTimestampValueConfig } from "./timestamp"
+import { title, type MockTitleValue, type MockTitleValueConfig } from "./title"
+import { uid, type MockUIDValueConfig } from "./uid"
 
 export const createValueMockFactory = (
 	...args: ConstructorParameters<typeof ValueMockFactory>
 ): ValueMockFactory => {
-	return new ValueMockFactory(...args);
-};
+	return new ValueMockFactory(...args)
+}
 
 type ValueMockFactoryConfig =
 	| {
-			seed: Seed;
+			seed: Seed
 	  }
 	| {
-			faker: Faker;
-	  };
+			faker: Faker
+	  }
 
 export class ValueMockFactory {
-	private faker: Faker;
+	private faker: Faker
 
 	constructor(config: ValueMockFactoryConfig) {
-		this.faker = "faker" in config ? config.faker : createFaker(config.seed);
+		this.faker = "faker" in config ? config.faker : createFaker(config.seed)
 	}
 
-	get seed() {
-		return this.faker.seed;
+	get seed(): Seed {
+		return this.faker.seed
 	}
 
 	boolean<Model extends prismic.CustomTypeModelBooleanField>(
 		config?: WithoutFakerConfig<MockBooleanValueConfig<Model>>,
-	) {
-		return boolean({ ...config, faker: this.faker });
+	): prismic.BooleanField {
+		return boolean({ ...config, faker: this.faker })
 	}
 
 	color<
-		Model extends
-			prismic.CustomTypeModelColorField = prismic.CustomTypeModelColorField,
+		Model extends prismic.CustomTypeModelColorField = prismic.CustomTypeModelColorField,
 		State extends prismic.FieldState = "filled",
-	>(config?: WithoutFakerConfig<MockColorValueConfig<Model, State>>) {
-		return color({ ...config, faker: this.faker });
+	>(config?: WithoutFakerConfig<MockColorValueConfig<Model, State>>): MockColorValue<State> {
+		return color({ ...config, faker: this.faker })
 	}
 
 	contentRelationship<
-		Model extends
-			prismic.CustomTypeModelContentRelationshipField = prismic.CustomTypeModelContentRelationshipField,
+		Model extends prismic.CustomTypeModelContentRelationshipField =
+			prismic.CustomTypeModelContentRelationshipField,
 		State extends prismic.FieldState = "filled",
 	>(
-		config?: WithoutFakerConfig<
-			MockContentRelationshipValueConfig<Model, State>
-		>,
-	) {
-		return contentRelationship({ ...config, faker: this.faker });
+		config?: WithoutFakerConfig<MockContentRelationshipValueConfig<Model, State>>,
+	): MockContentRelationshipValue<Model, State> {
+		return contentRelationship({ ...config, faker: this.faker })
 	}
 
 	customType<Model extends prismic.CustomTypeModel = prismic.CustomTypeModel>(
 		config?: WithoutFakerConfig<MockCustomTypeValueConfig<Model>>,
-	) {
-		return customType({ ...config, faker: this.faker });
+	): ModelValue<Model> {
+		return customType({ ...config, faker: this.faker })
 	}
 
 	date<
-		Model extends
-			prismic.CustomTypeModelDateField = prismic.CustomTypeModelDateField,
+		Model extends prismic.CustomTypeModelDateField = prismic.CustomTypeModelDateField,
 		State extends prismic.FieldState = "filled",
-	>(config?: WithoutFakerConfig<MockDateValueConfig<Model, State>>) {
-		return date({ ...config, faker: this.faker });
+	>(config?: WithoutFakerConfig<MockDateValueConfig<Model, State>>): MockDateValue<State> {
+		return date({ ...config, faker: this.faker })
 	}
 
 	document<Model extends prismic.CustomTypeModel = prismic.CustomTypeModel>(
 		config?: WithoutFakerConfig<MockDocumentValueConfig<Model>>,
-	) {
-		return document({ ...config, faker: this.faker });
+	): ModelValue<Model> {
+		return document({ ...config, faker: this.faker })
 	}
 
 	embed<
-		Model extends
-			prismic.CustomTypeModelEmbedField = prismic.CustomTypeModelEmbedField,
+		Model extends prismic.CustomTypeModelEmbedField = prismic.CustomTypeModelEmbedField,
 		Data extends prismic.AnyOEmbed = prismic.AnyOEmbed,
 		State extends prismic.FieldState = "filled",
-	>(config?: WithoutFakerConfig<MockEmbedValueConfig<Model, Data, State>>) {
-		return embed({ ...config, faker: this.faker });
+	>(
+		config?: WithoutFakerConfig<MockEmbedValueConfig<Model, Data, State>>,
+	): MockEmbedValue<Data, State> {
+		return embed({ ...config, faker: this.faker })
 	}
 
 	geoPoint<
-		Model extends
-			prismic.CustomTypeModelGeoPointField = prismic.CustomTypeModelGeoPointField,
+		Model extends prismic.CustomTypeModelGeoPointField = prismic.CustomTypeModelGeoPointField,
 		State extends prismic.FieldState = "filled",
-	>(config?: WithoutFakerConfig<MockGeoPointValueConfig<Model, State>>) {
-		return geoPoint({ ...config, faker: this.faker });
+	>(config?: WithoutFakerConfig<MockGeoPointValueConfig<Model, State>>): MockGeoPointValue<State> {
+		return geoPoint({ ...config, faker: this.faker })
 	}
 
 	group<
-		Model extends
-			prismic.CustomTypeModelGroupField = prismic.CustomTypeModelGroupField,
+		Model extends prismic.CustomTypeModelGroupField = prismic.CustomTypeModelGroupField,
 		State extends prismic.FieldState = "filled",
-	>(config?: WithoutFakerConfig<MockGroupValueConfig<Model, State>>) {
-		return group({ ...config, faker: this.faker });
+	>(config?: WithoutFakerConfig<MockGroupValueConfig<Model, State>>): ModelValue<Model, State> {
+		return group({ ...config, faker: this.faker })
 	}
 
 	image<
-		Model extends
-			prismic.CustomTypeModelImageField = prismic.CustomTypeModelImageField,
+		Model extends prismic.CustomTypeModelImageField = prismic.CustomTypeModelImageField,
 		State extends prismic.FieldState = "filled",
-	>(
-		config?: WithoutFakerConfig<MockImageValueConfig<Model, State>>,
-	): MockImageValue<Model, State> {
-		return image({ ...config, faker: this.faker });
+	>(config?: WithoutFakerConfig<MockImageValueConfig<Model, State>>): MockImageValue<Model, State> {
+		return image({ ...config, faker: this.faker })
 	}
 
 	integration<
-		Model extends
-			prismic.CustomTypeModelIntegrationField = prismic.CustomTypeModelIntegrationField,
+		Model extends prismic.CustomTypeModelIntegrationField = prismic.CustomTypeModelIntegrationField,
 		Data extends Record<string, unknown> = Record<string, unknown>,
 		State extends prismic.FieldState = "filled",
 	>(
-		config?: WithoutFakerConfig<
-			MockIntegrationFieldValueConfig<Model, Data, State>
-		>,
-	) {
-		return integration({ ...config, faker: this.faker });
+		config?: WithoutFakerConfig<MockIntegrationFieldValueConfig<Model, Data, State>>,
+	): MockIntegrationFieldValue<Data, State> {
+		return integration({ ...config, faker: this.faker })
 	}
 
 	keyText<
-		Model extends
-			prismic.CustomTypeModelKeyTextField = prismic.CustomTypeModelKeyTextField,
+		Model extends prismic.CustomTypeModelKeyTextField = prismic.CustomTypeModelKeyTextField,
 		State extends prismic.FieldState = "filled",
-	>(config?: WithoutFakerConfig<MockKeyTextValueConfig<Model, State>>) {
-		return keyText({ ...config, faker: this.faker });
+	>(config?: WithoutFakerConfig<MockKeyTextValueConfig<Model, State>>): MockKeyTextValue<State> {
+		return keyText({ ...config, faker: this.faker })
 	}
 
 	link<
-		LinkType extends
-			(typeof prismic.LinkType)[keyof typeof prismic.LinkType] = (typeof prismic.LinkType)[keyof typeof prismic.LinkType],
-		Model extends
-			prismic.CustomTypeModelLinkField = prismic.CustomTypeModelLinkField,
+		LinkType extends (typeof prismic.LinkType)[keyof typeof prismic.LinkType] =
+			(typeof prismic.LinkType)[keyof typeof prismic.LinkType],
+		Model extends prismic.CustomTypeModelLinkField = prismic.CustomTypeModelLinkField,
 		State extends prismic.FieldState = "filled",
-	>(config?: WithoutFakerConfig<MockLinkValueConfig<LinkType, Model, State>>) {
-		return link({ ...config, faker: this.faker });
+	>(
+		config?: WithoutFakerConfig<MockLinkValueConfig<LinkType, Model, State>>,
+	): MockLinkValue<LinkType, State> {
+		return link({ ...config, faker: this.faker })
 	}
 
 	linkToMedia<
-		Model extends
-			prismic.CustomTypeModelLinkToMediaField = prismic.CustomTypeModelLinkToMediaField,
+		Model extends prismic.CustomTypeModelLinkToMediaField = prismic.CustomTypeModelLinkToMediaField,
 		State extends prismic.FieldState = "filled",
-	>(config?: WithoutFakerConfig<MockLinkToMediaValueConfig<Model, State>>) {
-		return linkToMedia({ ...config, faker: this.faker });
+	>(
+		config?: WithoutFakerConfig<MockLinkToMediaValueConfig<Model, State>>,
+	): MockLinkToMediaValue<State> {
+		return linkToMedia({ ...config, faker: this.faker })
 	}
 
 	number<
-		Model extends
-			prismic.CustomTypeModelNumberField = prismic.CustomTypeModelNumberField,
+		Model extends prismic.CustomTypeModelNumberField = prismic.CustomTypeModelNumberField,
 		State extends prismic.FieldState = "filled",
-	>(config?: WithoutFakerConfig<MockNumberValueConfig<Model, State>>) {
-		return number({ ...config, faker: this.faker });
+	>(config?: WithoutFakerConfig<MockNumberValueConfig<Model, State>>): MockNumberValue<State> {
+		return number({ ...config, faker: this.faker })
 	}
 
 	richText<
-		Model extends
-			prismic.CustomTypeModelRichTextField = prismic.CustomTypeModelRichTextField,
-	>(config?: WithoutFakerConfig<MockRichTextValueConfig<Model>>) {
-		return richText({ ...config, faker: this.faker });
+		Model extends prismic.CustomTypeModelRichTextField = prismic.CustomTypeModelRichTextField,
+	>(config?: WithoutFakerConfig<MockRichTextValueConfig<Model>>): MockRichTextValue {
+		return richText({ ...config, faker: this.faker })
 	}
 
 	select<
-		Model extends
-			prismic.CustomTypeModelSelectField = prismic.CustomTypeModelSelectField,
+		Model extends prismic.CustomTypeModelSelectField = prismic.CustomTypeModelSelectField,
 		State extends prismic.FieldState = "filled",
-	>(config?: WithoutFakerConfig<MockSelectValueConfig<Model, State>>) {
-		return select({ ...config, faker: this.faker });
+	>(
+		config?: WithoutFakerConfig<MockSelectValueConfig<Model, State>>,
+	): MockSelectValue<Model, State> {
+		return select({ ...config, faker: this.faker })
 	}
 
-	sharedSlice<
-		Model extends prismic.SharedSliceModel = prismic.SharedSliceModel,
-	>(config?: WithoutFakerConfig<MockSharedSliceValueConfig<Model>>) {
-		return sharedSlice({ ...config, faker: this.faker });
+	sharedSlice<Model extends prismic.SharedSliceModel = prismic.SharedSliceModel>(
+		config?: WithoutFakerConfig<MockSharedSliceValueConfig<Model>>,
+	): ModelValue<Model> {
+		return sharedSlice({ ...config, faker: this.faker })
 	}
 
 	sharedSliceVariation<
-		Model extends
-			prismic.SharedSliceModelVariation = prismic.SharedSliceModelVariation,
-	>(config?: WithoutFakerConfig<MockSharedSliceVariationValueConfig<Model>>) {
-		return sharedSliceVariation({ ...config, faker: this.faker });
+		Model extends prismic.SharedSliceModelVariation = prismic.SharedSliceModelVariation,
+	>(config?: WithoutFakerConfig<MockSharedSliceVariationValueConfig<Model>>): ModelValue<Model> {
+		return sharedSliceVariation({ ...config, faker: this.faker })
 	}
 
-	slice<
-		Model extends prismic.CustomTypeModelSlice = prismic.CustomTypeModelSlice,
-	>(config?: WithoutFakerConfig<MockSliceValueConfig<Model>>) {
-		return slice({ ...config, faker: this.faker });
+	slice<Model extends prismic.CustomTypeModelSlice = prismic.CustomTypeModelSlice>(
+		config?: WithoutFakerConfig<MockSliceValueConfig<Model>>,
+	): ModelValue<Model> {
+		return slice({ ...config, faker: this.faker })
 	}
 
 	sliceZone<
-		Model extends
-			prismic.CustomTypeModelSliceZoneField = prismic.CustomTypeModelSliceZoneField,
+		Model extends prismic.CustomTypeModelSliceZoneField = prismic.CustomTypeModelSliceZoneField,
 		State extends prismic.FieldState = "filled",
-	>(config?: WithoutFakerConfig<MockSliceZoneValueConfig<Model, State>>) {
-		return sliceZone({ ...config, faker: this.faker });
+	>(config?: WithoutFakerConfig<MockSliceZoneValueConfig<Model, State>>): ModelValue<Model, State> {
+		return sliceZone({ ...config, faker: this.faker })
 	}
 
-	table<
-		Model extends
-			prismic.CustomTypeModelTableField = prismic.CustomTypeModelTableField,
-	>(config?: WithoutFakerConfig<MockTableValueConfig<Model>>) {
-		return table({ ...config, faker: this.faker });
+	table<Model extends prismic.CustomTypeModelTableField = prismic.CustomTypeModelTableField>(
+		config?: WithoutFakerConfig<MockTableValueConfig<Model>>,
+	): MockTableValue {
+		return table({ ...config, faker: this.faker })
 	}
 
 	timestamp<
-		Model extends
-			prismic.CustomTypeModelTimestampField = prismic.CustomTypeModelTimestampField,
+		Model extends prismic.CustomTypeModelTimestampField = prismic.CustomTypeModelTimestampField,
 		State extends prismic.FieldState = "filled",
-	>(config?: WithoutFakerConfig<MockTimestampValueConfig<Model, State>>) {
-		return timestamp({ ...config, faker: this.faker });
+	>(
+		config?: WithoutFakerConfig<MockTimestampValueConfig<Model, State>>,
+	): MockTimestampValue<State> {
+		return timestamp({ ...config, faker: this.faker })
 	}
 
 	title<
-		Model extends
-			prismic.CustomTypeModelTitleField = prismic.CustomTypeModelTitleField,
+		Model extends prismic.CustomTypeModelTitleField = prismic.CustomTypeModelTitleField,
 		State extends prismic.FieldState = "filled",
-	>(config?: WithoutFakerConfig<MockTitleValueConfig<Model, State>>) {
-		return title({ ...config, faker: this.faker });
+	>(config?: WithoutFakerConfig<MockTitleValueConfig<Model, State>>): MockTitleValue<State> {
+		return title({ ...config, faker: this.faker })
 	}
 
-	uid<
-		Model extends
-			prismic.CustomTypeModelUIDField = prismic.CustomTypeModelUIDField,
-	>(config?: WithoutFakerConfig<MockUIDValueConfig<Model>>) {
-		return uid({ ...config, faker: this.faker });
+	uid<Model extends prismic.CustomTypeModelUIDField = prismic.CustomTypeModelUIDField>(
+		config?: WithoutFakerConfig<MockUIDValueConfig<Model>>,
+	): NonNullable<prismic.PrismicDocument["uid"]> {
+		return uid({ ...config, faker: this.faker })
 	}
 }

package/src/value/customType.ts

@@ -1,65 +1,56 @@
-import * as prismic from "@prismicio/client";
+import * as prismic from "@prismicio/client"
 
-import { snakeCase } from "../lib/changeCase";
-import { createFaker } from "../lib/createFaker";
-import { generateTags } from "../lib/generateTags";
-import {
-	valueForModelMap,
-	ValueForModelMapConfigs,
-} from "../lib/valueForModelMap";
-
-import { MockValueConfig, ModelValue } from "../types";
-
-import * as modelGen from "../model";
-
-import { timestamp } from "./timestamp";
-import { buildAlternativeLanguage } from "../lib/buildAlternativeLanguage";
+import { buildAlternativeLanguage } from "../lib/buildAlternativeLanguage"
+import { snakeCase } from "../lib/changeCase"
+import { createFaker } from "../lib/createFaker"
+import { generateTags } from "../lib/generateTags"
+import { valueForModelMap, type ValueForModelMapConfigs } from "../lib/valueForModelMap"
+import * as modelGen from "../model"
+import type { MockValueConfig, ModelValue } from "../types"
+import { timestamp } from "./timestamp"
 
 export type MockCustomTypeValueConfig<
 	Model extends prismic.CustomTypeModel = prismic.CustomTypeModel,
 > = {
-	withURL?: boolean;
-	alternateLanguages?: prismic.PrismicDocument[];
-	configs?: ValueForModelMapConfigs;
-} & MockValueConfig<Model>;
+	withURL?: boolean
+	alternateLanguages?: prismic.PrismicDocument[]
+	configs?: ValueForModelMapConfigs
+} & MockValueConfig<Model>
 
-export const customType = <
-	Model extends prismic.CustomTypeModel = prismic.CustomTypeModel,
->(
+export const customType = <Model extends prismic.CustomTypeModel = prismic.CustomTypeModel>(
 	config: MockCustomTypeValueConfig<Model>,
 ): ModelValue<Model> => {
-	const faker = config.faker || createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed)
 
-	const model = config.model || modelGen.customType({ faker });
+	const model = config.model || modelGen.customType({ faker })
 
 	const fieldModelsMap = Object.assign(
 		{},
 		...Object.values(model.json),
-	) as prismic.CustomTypeModelTab;
+	) as prismic.CustomTypeModelTab
 
-	const dataFieldModelsMap: prismic.CustomTypeModelTab = {};
+	const dataFieldModelsMap: prismic.CustomTypeModelTab = {}
 	for (const key in fieldModelsMap) {
-		const fieldModel = fieldModelsMap[key];
+		const fieldModel = fieldModelsMap[key]
 
 		// UID fields must be filtered out since they are not represented in
 		// the document's `data` field.
 		if (fieldModel.type !== prismic.CustomTypeModelFieldType.UID) {
-			dataFieldModelsMap[key] = fieldModel;
+			dataFieldModelsMap[key] = fieldModel
 		}
 	}
 
 	const hasUID = Object.values(fieldModelsMap).some(
 		(fieldModel) => fieldModel.type === prismic.CustomTypeModelFieldType.UID,
-	);
+	)
 
-	const withURL = config.withURL ?? true;
+	const withURL = config.withURL ?? true
 
-	const alternateLanguages = (config.alternateLanguages || []).map(
-		(alternateLanguageDocument) =>
-			buildAlternativeLanguage({
-				document: alternateLanguageDocument,
-			}),
-	);
+	const alternateLanguages = (config.alternateLanguages || []).map((alternateLanguageDocument) =>
+		buildAlternativeLanguage({
+			document: alternateLanguageDocument,
+		}),
+	)
 
 	return {
 		type: model.id,
@@ -79,5 +70,5 @@ export const customType = <
 			map: dataFieldModelsMap,
 			configs: config.configs,
 		}),
-	} as ModelValue<Model>;
-};
+	} as ModelValue<Model>
+}

package/src/value/date.ts

@@ -1,31 +1,26 @@
-import * as prismic from "@prismicio/client";
+import type * as prismic from "@prismicio/client"
 
-import { createFaker } from "../lib/createFaker";
-
-import { MockValueStateConfig, MockValueConfig } from "../types";
-
-import { MockTimestampValueConfig, timestamp } from "./timestamp";
+import { createFaker } from "../lib/createFaker"
+import type { MockValueStateConfig, MockValueConfig } from "../types"
+import { timestamp, type MockTimestampValueConfig } from "./timestamp"
 
 export type MockDateValueConfig<
-	Model extends
-		prismic.CustomTypeModelDateField = prismic.CustomTypeModelDateField,
+	Model extends prismic.CustomTypeModelDateField = prismic.CustomTypeModelDateField,
 	State extends prismic.FieldState = prismic.FieldState,
 > = Pick<MockTimestampValueConfig, "after" | "before"> &
 	MockValueConfig<Model> &
-	MockValueStateConfig<State>;
+	MockValueStateConfig<State>
 
-export type MockDateValue<
-	State extends prismic.FieldState = prismic.FieldState,
-> = prismic.DateField<State>;
+export type MockDateValue<State extends prismic.FieldState = prismic.FieldState> =
+	prismic.DateField<State>
 
 export const date = <
-	Model extends
-		prismic.CustomTypeModelDateField = prismic.CustomTypeModelDateField,
+	Model extends prismic.CustomTypeModelDateField = prismic.CustomTypeModelDateField,
 	State extends prismic.FieldState = "filled",
 >(
 	config: MockDateValueConfig<Model, State>,
 ): MockDateValue<State> => {
-	const faker = config.faker || createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed)
 
 	return (
 		config.state === "empty"
@@ -36,5 +31,5 @@ export const date = <
 					before: config.before,
 					state: "filled",
 				}).split("T")[0]
-	) as MockDateValue<State>;
-};
+	) as MockDateValue<State>
+}

package/src/value/document.ts

@@ -1,5 +1,3 @@
 // "document" is an alias for "customType"
-export {
-	customType as document,
-	MockCustomTypeValueConfig as MockDocumentValueConfig,
-} from "./customType";
+export { customType as document } from "./customType"
+export type { MockCustomTypeValueConfig as MockDocumentValueConfig } from "./customType"

package/src/value/embed.ts

@@ -1,39 +1,36 @@
-import * as prismic from "@prismicio/client";
+import type * as prismic from "@prismicio/client"
 
-import { buildEmbedField } from "../lib/buildEmbedField";
-import { createFaker } from "../lib/createFaker";
-import { getMockEmbedData } from "../lib/getMockEmbedData";
-
-import { MockValueStateConfig, MockValueConfig } from "../types";
+import { buildEmbedField } from "../lib/buildEmbedField"
+import { createFaker } from "../lib/createFaker"
+import { getMockEmbedData } from "../lib/getMockEmbedData"
+import type { MockValueStateConfig, MockValueConfig } from "../types"
 
 export type MockEmbedValueConfig<
-	Model extends
-		prismic.CustomTypeModelEmbedField = prismic.CustomTypeModelEmbedField,
+	Model extends prismic.CustomTypeModelEmbedField = prismic.CustomTypeModelEmbedField,
 	Data extends prismic.AnyOEmbed = prismic.AnyOEmbed,
 	State extends prismic.FieldState = prismic.FieldState,
 > = {
-	url?: string;
-	html?: string;
-	data?: Data;
+	url?: string
+	html?: string
+	data?: Data
 } & MockValueConfig<Model> &
-	MockValueStateConfig<State>;
+	MockValueStateConfig<State>
 
 export type MockEmbedValue<
 	Data extends prismic.AnyOEmbed = prismic.AnyOEmbed,
 	State extends prismic.FieldState = prismic.FieldState,
-> = prismic.EmbedField<Data, State>;
+> = prismic.EmbedField<Data, State>
 
 export const embed = <
-	Model extends
-		prismic.CustomTypeModelEmbedField = prismic.CustomTypeModelEmbedField,
+	Model extends prismic.CustomTypeModelEmbedField = prismic.CustomTypeModelEmbedField,
 	Data extends prismic.AnyOEmbed = prismic.AnyOEmbed,
 	State extends prismic.FieldState = "filled",
 >(
 	config: MockEmbedValueConfig<Model, Data, State>,
 ): MockEmbedValue<Data, State> => {
-	const faker = config.faker || createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed)
 
-	const data = config.data ?? getMockEmbedData({ faker });
+	const data = config.data ?? getMockEmbedData({ faker })
 
 	return (
 		config.state === "empty"
@@ -44,5 +41,5 @@ export const embed = <
 					html: config.html ?? ("html" in data ? data.html : undefined),
 					data,
 				})
-	) as MockEmbedValue<Data, State>;
-};
+	) as MockEmbedValue<Data, State>
+}