Socket
Socket
Sign inDemoInstall

@prismicio/mock

Package Overview
Dependencies
Maintainers
19
Versions
29
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@prismicio/mock - npm Package Compare versions

Comparing version 0.0.6 to 0.0.7

dist/api/index.cjs.map
dist/api/index.d.ts.map
dist/api/index.js
dist/api/index.js.map
dist/index.cjs.map
dist/index.js
dist/index.js.map
dist/model/index.cjs.map
dist/model/index.d.ts.map
dist/model/index.js
dist/model/index.js.map
dist/value/index.cjs.map
dist/value/index.d.ts.map
dist/value/index.js
dist/value/index.js.map
src/lib/buildImageFieldImage.ts
src/model/buildMockGroupFieldMap.ts

3

dist/api/index.d.ts

@@ -30,3 +30,3 @@ import * as prismicT from '@prismicio/types';

} & MockRestApiConfig;
declare const query: <Document_1 extends prismicT.PrismicDocument<Record<string, prismicT.AnyRegularField | prismicT.GroupField<Record<string, prismicT.AnyRegularField>> | prismicT.SliceZone<prismicT.Slice<string, Record<string, prismicT.AnyRegularField>, Record<string, prismicT.AnyRegularField>> | prismicT.SharedSlice<string, prismicT.SharedSliceVariation<string, Record<string, prismicT.AnyRegularField>, Record<string, prismicT.AnyRegularField>>>>>, string, string> = prismicT.PrismicDocument<Record<string, prismicT.AnyRegularField | prismicT.GroupField<Record<string, prismicT.AnyRegularField>> | prismicT.SliceZone<prismicT.Slice<string, Record<string, prismicT.AnyRegularField>, Record<string, prismicT.AnyRegularField>> | prismicT.SharedSlice<string, prismicT.SharedSliceVariation<string, Record<string, prismicT.AnyRegularField>, Record<string, prismicT.AnyRegularField>>>>>, string, string>>(config?: MockRestApiQueryConfig<Document_1>) => prismicT.Query<Document_1>;
declare const query: <Document_1 extends prismicT.PrismicDocument<Record<string, any>, string, string> = prismicT.PrismicDocument<Record<string, any>, string, string>>(config?: MockRestApiQueryConfig<Document_1>) => prismicT.Query<Document_1>;

@@ -37,1 +37,2 @@ declare type MockRestApiTagsConfig = MockRestApiConfig;

export { MockRestApiQueryConfig, MockRestApiRefConfig, MockRestApiRefValue, MockRestApiRepositoryConfig, MockRestApiTagsConfig, query, ref, repository, tags };
//# sourceMappingURL=index.d.ts.map

362

dist/index.d.ts

@@ -35,7 +35,6 @@ import * as prismicT from '@prismicio/types';

declare type MockColorValueConfig<Model extends prismicT.CustomTypeModelColorField = prismicT.CustomTypeModelColorField> = MockValueConfig<Model>;
declare const color$1: (config?: MockColorValueConfig) => prismicT.ColorField;
declare type MockColorValueConfig<Model extends prismicT.CustomTypeModelColorField = prismicT.CustomTypeModelColorField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
declare const color$1: <Model extends prismicT.CustomTypeModelColorField = prismicT.CustomTypeModelColorField, State extends prismicT.FieldState = "filled">(config?: MockColorValueConfig<Model, State>) => prismicT.ColorField<State>;
declare type MockContentRelationshipValueConfig<IsFilled extends boolean = boolean, Model extends prismicT.CustomTypeModelContentRelationshipField = prismicT.CustomTypeModelContentRelationshipField> = {
isFilled?: IsFilled;
declare type MockContentRelationshipValueConfig<Model extends prismicT.CustomTypeModelContentRelationshipField = prismicT.CustomTypeModelContentRelationshipField, State extends prismicT.FieldState = prismicT.FieldState> = {
/**

@@ -45,37 +44,22 @@ * A list of potential documents to which the field can be linked.

linkableDocuments?: prismicT.PrismicDocument[];
} & MockValueConfig<Model>;
declare type MockContentRelationshipValue<IsFilled extends boolean = boolean> = IsFilled extends true ? prismicT.FilledLinkToDocumentField : prismicT.EmptyLinkField<prismicT.LinkType.Document>;
declare const contentRelationship$1: <IsFilled extends boolean = true, Model extends prismicT.CustomTypeModelContentRelationshipField = prismicT.CustomTypeModelContentRelationshipField>(config?: MockContentRelationshipValueConfig<IsFilled, Model>) => MockContentRelationshipValue<IsFilled>;
} & MockValueConfig<Model> & MockValueStateConfig<State>;
declare const contentRelationship$1: <Model extends prismicT.CustomTypeModelContentRelationshipField<string, string> = prismicT.CustomTypeModelContentRelationshipField<string, string>, State extends prismicT.FieldState = "filled">(config?: MockContentRelationshipValueConfig<Model, State>) => prismicT.RelationField<Model["config"]["customtypes"], string, never, State>;
declare type MockTimestampValueConfig<Model extends prismicT.CustomTypeModelTimestampField = prismicT.CustomTypeModelTimestampField> = {
declare type MockTimestampValueConfig<Model extends prismicT.CustomTypeModelTimestampField = prismicT.CustomTypeModelTimestampField, State extends prismicT.FieldState = prismicT.FieldState> = {
after?: Date;
before?: Date;
} & MockValueConfig<Model>;
declare const timestamp$1: (config?: MockTimestampValueConfig) => prismicT.TimestampField;
} & MockValueConfig<Model> & MockValueStateConfig<State>;
declare const timestamp$1: <Model extends prismicT.CustomTypeModelTimestampField = prismicT.CustomTypeModelTimestampField, State extends prismicT.FieldState = "filled">(config?: MockTimestampValueConfig<Model, State>) => prismicT.TimestampField<State>;
declare type MockDateValueConfig<Model extends prismicT.CustomTypeModelDateField = prismicT.CustomTypeModelDateField> = Pick<MockTimestampValueConfig, "after" | "before"> & MockValueConfig<Model>;
declare const date$1: (config?: MockDateValueConfig) => prismicT.DateField;
declare type MockDateValueConfig<Model extends prismicT.CustomTypeModelDateField = prismicT.CustomTypeModelDateField, State extends prismicT.FieldState = prismicT.FieldState> = Pick<MockTimestampValueConfig, "after" | "before"> & MockValueConfig<Model> & MockValueStateConfig<State>;
declare const date$1: <Model extends prismicT.CustomTypeModelDateField = prismicT.CustomTypeModelDateField, State extends prismicT.FieldState = "filled">(config?: MockDateValueConfig<Model, State>) => prismicT.DateField<State>;
declare type MockEmbedValueConfig<Model extends prismicT.CustomTypeModelEmbedField = prismicT.CustomTypeModelEmbedField> = MockValueConfig<Model>;
declare const embed$1: (config?: MockEmbedValueConfig) => prismicT.EmbedField;
declare type MockEmbedValueConfig<Model extends prismicT.CustomTypeModelEmbedField = prismicT.CustomTypeModelEmbedField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
declare const embed$1: <Model extends prismicT.CustomTypeModelEmbedField = prismicT.CustomTypeModelEmbedField, State extends prismicT.FieldState = "filled">(config?: MockEmbedValueConfig<Model, State>) => prismicT.EmbedField<prismicT.AnyOEmbed & prismicT.OEmbedExtra, State>;
declare type MockGeoPointValueConfig<Model extends prismicT.CustomTypeModelGeoPointField = prismicT.CustomTypeModelGeoPointField> = MockValueConfig<Model>;
declare const geoPoint$1: (config?: MockGeoPointValueConfig) => prismicT.GeoPointField;
declare type MockGeoPointValueConfig<Model extends prismicT.CustomTypeModelGeoPointField = prismicT.CustomTypeModelGeoPointField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
declare const geoPoint$1: <Model extends prismicT.CustomTypeModelGeoPointField = prismicT.CustomTypeModelGeoPointField, State extends prismicT.FieldState = "filled">(config?: MockGeoPointValueConfig<Model, State>) => prismicT.GeoPointField<State>;
declare const patterns$5: {
readonly short: {
readonly minItems: 1;
readonly maxItems: 3;
};
readonly medium: {
readonly minItems: 3;
readonly maxItems: 6;
};
readonly long: {
readonly minItems: 6;
readonly maxItems: 12;
};
};
declare type MockGroupValueConfig<Model extends prismicT.CustomTypeModelGroupField = prismicT.CustomTypeModelGroupField> = {
pattern?: keyof typeof patterns$5;
itemsCount?: number;
configs?: ValueForModelMapConfigs;

@@ -85,16 +69,15 @@ } & MockValueConfig<Model>;

declare type MockImageValueConfig<Model extends prismicT.CustomTypeModelImageField = prismicT.CustomTypeModelImageField> = MockValueConfig<Model>;
declare const image$1: (config?: MockImageValueConfig) => prismicT.ImageField;
declare type MockImageValueConfig<Model extends prismicT.CustomTypeModelImageField = prismicT.CustomTypeModelImageField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
declare const image$1: <Model extends prismicT.CustomTypeModelImageField<string> = prismicT.CustomTypeModelImageField<string>, State extends prismicT.FieldState = "filled">(config?: MockImageValueConfig<Model, State>) => prismicT.ImageField<Model["config"]["thumbnails"][number]["name"], State>;
declare type MockIntegrationFieldsValueConfig<Model extends prismicT.CustomTypeModelIntegrationFieldsField = prismicT.CustomTypeModelIntegrationFieldsField, Blob extends unknown = unknown> = {
declare type MockIntegrationFieldsValueConfig<Model extends prismicT.CustomTypeModelIntegrationFieldsField = prismicT.CustomTypeModelIntegrationFieldsField, Blob = unknown, State extends prismicT.FieldState = prismicT.FieldState> = {
data?: Blob;
} & MockValueConfig<Model>;
declare const integrationFields$1: <Model extends prismicT.CustomTypeModelIntegrationFieldsField = prismicT.CustomTypeModelIntegrationFieldsField, Blob_1 extends unknown = unknown>(config?: MockIntegrationFieldsValueConfig<Model, Blob_1>) => prismicT.IntegrationFields<Blob_1>;
} & MockValueConfig<Model> & MockValueStateConfig<State>;
declare const integrationFields$1: <Model extends prismicT.CustomTypeModelIntegrationFieldsField = prismicT.CustomTypeModelIntegrationFieldsField, Blob_1 = unknown, State extends prismicT.FieldState = "filled">(config?: MockIntegrationFieldsValueConfig<Model, Blob_1, State>) => prismicT.IntegrationFields<Blob_1, State>;
declare type MockKeyTextValueConfig<Model extends prismicT.CustomTypeModelKeyTextField = prismicT.CustomTypeModelKeyTextField> = MockValueConfig<Model>;
declare const keyText$1: (config?: MockKeyTextValueConfig) => prismicT.KeyTextField;
declare type MockKeyTextValueConfig<Model extends prismicT.CustomTypeModelKeyTextField = prismicT.CustomTypeModelKeyTextField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
declare const keyText$1: <Model extends prismicT.CustomTypeModelKeyTextField = prismicT.CustomTypeModelKeyTextField, State extends prismicT.FieldState = "filled">(config?: MockKeyTextValueConfig<Model, State>) => prismicT.KeyTextField<State>;
declare type MockLinkValueConfig<LinkType extends prismicT.LinkType = prismicT.LinkType, IsFilled extends boolean = true, Model extends prismicT.CustomTypeModelLinkField = prismicT.CustomTypeModelLinkField> = {
declare type MockLinkValueConfig<LinkType extends typeof prismicT.LinkType[keyof typeof prismicT.LinkType] = typeof prismicT.LinkType[keyof typeof prismicT.LinkType], Model extends prismicT.CustomTypeModelLinkField = prismicT.CustomTypeModelLinkField, State extends prismicT.FieldState = prismicT.FieldState> = {
type?: LinkType;
isFilled?: IsFilled;
withTargetBlank?: Model["config"]["allowTargetBlank"] extends undefined ? false : boolean;

@@ -104,17 +87,14 @@ /**

*/
linkableDocuments?: LinkType extends prismicT.LinkType.Document ? prismicT.PrismicDocument[] : never;
} & MockValueConfig<Model>;
declare type MockLinkValue<LinkType extends prismicT.LinkType = prismicT.LinkType, IsFilled extends boolean = true> = IsFilled extends true ? LinkType extends prismicT.LinkType.Web ? prismicT.FilledLinkToWebField : LinkType extends prismicT.LinkType.Media ? prismicT.FilledLinkToMediaField : LinkType extends prismicT.LinkType.Document ? prismicT.FilledLinkToDocumentField : never : prismicT.EmptyLinkField<LinkType>;
declare const link$1: <LinkType extends prismicT.LinkType = prismicT.LinkType, IsFilled extends boolean = true, Model extends prismicT.CustomTypeModelLinkField = prismicT.CustomTypeModelLinkField>(config?: MockLinkValueConfig<LinkType, IsFilled, Model>) => MockLinkValue<LinkType, IsFilled>;
linkableDocuments?: LinkType extends typeof prismicT.LinkType.Document ? prismicT.PrismicDocument[] : never;
} & MockValueConfig<Model> & MockValueStateConfig<State>;
declare type MockLinkValue<LinkType extends typeof prismicT.LinkType[keyof typeof prismicT.LinkType] = typeof prismicT.LinkType[keyof typeof prismicT.LinkType], State extends prismicT.FieldState = "filled"> = State extends "empty" ? prismicT.EmptyLinkField<LinkType> : LinkType extends typeof prismicT.LinkType.Web ? prismicT.FilledLinkToWebField : LinkType extends typeof prismicT.LinkType.Media ? prismicT.FilledLinkToMediaField : LinkType extends typeof prismicT.LinkType.Document ? prismicT.FilledLinkToDocumentField : never;
declare const link$1: <LinkType extends "Any" | "Document" | "Media" | "Web" = "Any" | "Document" | "Media" | "Web", Model extends prismicT.CustomTypeModelLinkField = prismicT.CustomTypeModelLinkField, State extends prismicT.FieldState = "filled">(config?: MockLinkValueConfig<LinkType, Model, State>) => MockLinkValue<LinkType, State>;
declare type MockLinkToMediaValueConfig<IsFilled extends boolean = true, Model extends prismicT.CustomTypeModelLinkToMediaField = prismicT.CustomTypeModelLinkToMediaField> = {
isFilled?: IsFilled;
} & MockValueConfig<Model>;
declare type MockLinkToMediaValue<IsFilled extends boolean = true> = IsFilled extends true ? prismicT.FilledLinkToMediaField : prismicT.EmptyLinkField<prismicT.LinkType.Media>;
declare const linkToMedia$1: <IsFilled extends boolean = true, Model extends prismicT.CustomTypeModelLinkToMediaField = prismicT.CustomTypeModelLinkToMediaField>(config?: MockLinkToMediaValueConfig<IsFilled, Model>) => MockLinkToMediaValue<IsFilled>;
declare type MockLinkToMediaValueConfig<Model extends prismicT.CustomTypeModelLinkToMediaField = prismicT.CustomTypeModelLinkToMediaField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
declare const linkToMedia$1: <Model extends prismicT.CustomTypeModelLinkToMediaField = prismicT.CustomTypeModelLinkToMediaField, State extends prismicT.FieldState = "filled">(config?: MockLinkToMediaValueConfig<Model, State>) => prismicT.LinkToMediaField<State>;
declare type MockNumberValueConfig<Model extends prismicT.CustomTypeModelNumberField = prismicT.CustomTypeModelNumberField> = MockValueConfig<Model>;
declare const number$1: (config?: MockNumberValueConfig) => prismicT.NumberField;
declare type MockNumberValueConfig<Model extends prismicT.CustomTypeModelNumberField = prismicT.CustomTypeModelNumberField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
declare const number$1: <Model extends prismicT.CustomTypeModelNumberField = prismicT.CustomTypeModelNumberField, State extends prismicT.FieldState = "filled">(config?: MockNumberValueConfig<Model, State>) => prismicT.NumberField<State>;
declare const patterns$4: {
declare const patterns$1: {
readonly short: {

@@ -134,31 +114,13 @@ readonly blockCountMin: 1;

declare type MockRichTextValueConfig$1 = {
pattern?: keyof typeof patterns$4;
pattern?: keyof typeof patterns$1;
} & MockRichTextValueConfig<prismicT.CustomTypeModelRichTextField>;
declare const richText$1: (config?: MockRichTextValueConfig$1) => prismicT.RichTextField;
declare type MockSelectValueConfig<Model extends prismicT.CustomTypeModelSelectField = prismicT.CustomTypeModelSelectField> = MockValueConfig<Model>;
declare const select$1: (config?: MockSelectValueConfig) => prismicT.SelectField;
declare type MockSelectValueConfig<Model extends prismicT.CustomTypeModelSelectField = prismicT.CustomTypeModelSelectField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
declare const select$1: <Model extends prismicT.CustomTypeModelSelectField<string, string> = prismicT.CustomTypeModelSelectField<string, string>, State extends prismicT.FieldState = "filled">(config?: MockSelectValueConfig<Model, State>) => prismicT.SelectField<Model["config"]["options"][number], State>;
declare const patterns$3: {
readonly none: {
readonly minItems: 0;
readonly maxItems: 0;
};
readonly short: {
readonly minItems: 1;
readonly maxItems: 3;
};
readonly medium: {
readonly minItems: 3;
readonly maxItems: 6;
};
readonly long: {
readonly minItems: 6;
readonly maxItems: 12;
};
};
declare type MockSliceValueConfig<Model extends prismicT.CustomTypeModelSlice = prismicT.CustomTypeModelSlice> = {
type?: string;
label?: string | null;
pattern?: keyof typeof patterns$3;
itemsCount?: number;
primaryFieldConfigs?: ValueForModelMapConfigs;

@@ -169,19 +131,5 @@ itemsFieldConfigs?: ValueForModelMapConfigs;

declare const patterns$2: {
readonly short: {
readonly minItems: 1;
readonly maxItems: 3;
};
readonly medium: {
readonly minItems: 3;
readonly maxItems: 6;
};
readonly long: {
readonly minItems: 6;
readonly maxItems: 12;
};
};
declare type MockSliceZoneValueConfig<Model extends prismicT.CustomTypeModelSliceZoneField = prismicT.CustomTypeModelSliceZoneField> = {
sharedSliceModels?: prismicT.SharedSliceModel[];
pattern?: keyof typeof patterns$2;
itemsCount?: number;
primaryFieldConfigs?: ValueForModelMapConfigs;

@@ -192,31 +140,13 @@ itemsFieldConfigs?: ValueForModelMapConfigs;

declare const patterns$1: {
readonly none: {
readonly minItems: 0;
readonly maxItems: 0;
};
readonly short: {
readonly minItems: 1;
readonly maxItems: 3;
};
readonly medium: {
readonly minItems: 3;
readonly maxItems: 6;
};
readonly long: {
readonly minItems: 6;
readonly maxItems: 12;
};
};
declare type MockSharedSliceVariationValueConfig<Model extends prismicT.SharedSliceModelVariation = prismicT.SharedSliceModelVariation> = {
type?: string;
label?: string;
pattern?: keyof typeof patterns$1;
itemsCount?: number;
primaryFieldConfigs?: ValueForModelMapConfigs;
itemsFieldConfigs?: ValueForModelMapConfigs;
} & MockValueConfig<Model>;
declare const sharedSliceVariation$1: <Model extends prismicT.SharedSliceModelVariation<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>> = prismicT.SharedSliceModelVariation<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>>(config?: MockSharedSliceVariationValueConfig<Model>) => ModelValue<Model>;
declare const sharedSliceVariation$1: <Model extends prismicT.SharedSliceModelVariation<string, Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>> = prismicT.SharedSliceModelVariation<string, Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>>(config?: MockSharedSliceVariationValueConfig<Model>) => ModelValue<Model>;
declare type MockSharedSliceValueConfig<Model extends prismicT.SharedSliceModel = prismicT.SharedSliceModel> = Pick<MockSharedSliceVariationValueConfig, "pattern" | "primaryFieldConfigs" | "itemsFieldConfigs"> & MockValueConfig<Model>;
declare const sharedSlice$1: <Model extends prismicT.SharedSliceModel<string, prismicT.SharedSliceModelVariation<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>> = prismicT.SharedSliceModel<string, prismicT.SharedSliceModelVariation<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>>>(config?: MockSharedSliceValueConfig<Model>) => ModelValue<Model>;
declare type MockSharedSliceValueConfig<Model extends prismicT.SharedSliceModel = prismicT.SharedSliceModel> = Pick<MockSharedSliceVariationValueConfig, "itemsCount" | "primaryFieldConfigs" | "itemsFieldConfigs"> & MockValueConfig<Model>;
declare const sharedSlice$1: <Model extends prismicT.SharedSliceModel<string, prismicT.SharedSliceModelVariation<string, Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>> = prismicT.SharedSliceModel<string, prismicT.SharedSliceModelVariation<string, Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>>>(config?: MockSharedSliceValueConfig<Model>) => ModelValue<Model>;

@@ -247,19 +177,19 @@ declare const patterns: {

declare type MockUIDValueConfig<Model extends prismicT.CustomTypeModelUIDField = prismicT.CustomTypeModelUIDField> = MockValueConfig<Model>;
declare const uid$1: (config?: MockUIDValueConfig) => prismicT.PrismicDocument["uid"];
declare const uid$1: (config?: MockUIDValueConfig) => NonNullable<prismicT.PrismicDocument["uid"]>;
type index$2_MockBooleanValueConfig<_0> = MockBooleanValueConfig<_0>;
type index$2_MockCustomTypeValueConfig<_0> = MockCustomTypeValueConfig<_0>;
type index$2_MockColorValueConfig<_0> = MockColorValueConfig<_0>;
type index$2_MockColorValueConfig<_0, _1> = MockColorValueConfig<_0, _1>;
type index$2_MockContentRelationshipValueConfig<_0, _1> = MockContentRelationshipValueConfig<_0, _1>;
type index$2_MockDateValueConfig<_0> = MockDateValueConfig<_0>;
type index$2_MockEmbedValueConfig<_0> = MockEmbedValueConfig<_0>;
type index$2_MockGeoPointValueConfig<_0> = MockGeoPointValueConfig<_0>;
type index$2_MockDateValueConfig<_0, _1> = MockDateValueConfig<_0, _1>;
type index$2_MockEmbedValueConfig<_0, _1> = MockEmbedValueConfig<_0, _1>;
type index$2_MockGeoPointValueConfig<_0, _1> = MockGeoPointValueConfig<_0, _1>;
type index$2_MockGroupValueConfig<_0> = MockGroupValueConfig<_0>;
type index$2_MockImageValueConfig<_0> = MockImageValueConfig<_0>;
type index$2_MockIntegrationFieldsValueConfig<_0, _1> = MockIntegrationFieldsValueConfig<_0, _1>;
type index$2_MockKeyTextValueConfig<_0> = MockKeyTextValueConfig<_0>;
type index$2_MockImageValueConfig<_0, _1> = MockImageValueConfig<_0, _1>;
type index$2_MockIntegrationFieldsValueConfig<_0, _1, _2> = MockIntegrationFieldsValueConfig<_0, _1, _2>;
type index$2_MockKeyTextValueConfig<_0, _1> = MockKeyTextValueConfig<_0, _1>;
type index$2_MockLinkValueConfig<_0, _1, _2> = MockLinkValueConfig<_0, _1, _2>;
type index$2_MockLinkToMediaValueConfig<_0, _1> = MockLinkToMediaValueConfig<_0, _1>;
type index$2_MockNumberValueConfig<_0> = MockNumberValueConfig<_0>;
type index$2_MockSelectValueConfig<_0> = MockSelectValueConfig<_0>;
type index$2_MockNumberValueConfig<_0, _1> = MockNumberValueConfig<_0, _1>;
type index$2_MockSelectValueConfig<_0, _1> = MockSelectValueConfig<_0, _1>;
type index$2_MockSliceValueConfig<_0> = MockSliceValueConfig<_0>;

@@ -269,3 +199,3 @@ type index$2_MockSliceZoneValueConfig<_0> = MockSliceZoneValueConfig<_0>;

type index$2_MockSharedSliceVariationValueConfig<_0> = MockSharedSliceVariationValueConfig<_0>;
type index$2_MockTimestampValueConfig<_0> = MockTimestampValueConfig<_0>;
type index$2_MockTimestampValueConfig<_0, _1> = MockTimestampValueConfig<_0, _1>;
type index$2_MockTitleValueConfig<_0> = MockTitleValueConfig<_0>;

@@ -327,3 +257,3 @@ type index$2_MockUIDValueConfig<_0> = MockUIDValueConfig<_0>;

declare type IterableElement<TargetIterable> = TargetIterable extends Iterable<infer ElementType> ? ElementType : TargetIterable extends AsyncIterable<infer ElementType> ? ElementType : never;
declare type ValueOf<ObjectType, ValueType extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType];
declare type ValueOf<ObjectType extends Record<string, unknown>> = ObjectType[string];
declare type Seed = string | number | number[];

@@ -337,2 +267,3 @@ declare type MockRestApiConfig = {

declare type PrismicModel = prismicT.CustomTypeModel | prismicT.CustomTypeModelField | prismicT.CustomTypeModelSlice | prismicT.SharedSliceModel | prismicT.SharedSliceModelVariation;
declare type GroupFieldModelMap = Record<string, prismicT.CustomTypeModelFieldForGroup>;
declare type MockValueConfig<Model extends PrismicModel = PrismicModel> = {

@@ -342,2 +273,5 @@ seed?: Seed;

};
declare type MockValueStateConfig<State extends prismicT.FieldState = prismicT.FieldState> = {
state?: State;
};
declare type CustomTypeModelStructuredTextField = prismicT.CustomTypeModelRichTextField | prismicT.CustomTypeModelTitleField;

@@ -351,7 +285,11 @@ declare type MockRichTextValueConfig<Model extends CustomTypeModelStructuredTextField = CustomTypeModelStructuredTextField> = {

};
declare type ModelValue<T extends PrismicModel> = T extends prismicT.CustomTypeModel ? CustomTypeModelValue<T> : T extends prismicT.CustomTypeModelUIDField ? prismicT.PrismicDocument["uid"] : T extends prismicT.CustomTypeModelFieldForGroup ? CustomTypeModelFieldForGroupValue<T> : T extends prismicT.CustomTypeModelGroupField ? CustomTypeModelGroupFieldValue<T> : T extends prismicT.CustomTypeModelSliceZoneField ? prismicT.SliceZone : T extends prismicT.CustomTypeModelSlice ? CustomTypeModelSliceValue<T> : T extends prismicT.CustomTypeModelSharedSlice ? prismicT.SharedSlice : T extends prismicT.SharedSliceModel ? SharedSliceModelValue<T> : T extends prismicT.SharedSliceModelVariation ? SharedSliceModelVariationValue<T> : never;
declare type CustomTypeModelValue<T extends prismicT.CustomTypeModel> = prismicT.PrismicDocument<ModelValueMap<ValueOf<T["json"]>>>;
declare type ModelValue<T extends PrismicModel> = T extends prismicT.CustomTypeModel ? CustomTypeModelValue<T> : T extends prismicT.CustomTypeModelUIDField ? prismicT.PrismicDocument["uid"] : T extends prismicT.CustomTypeModelFieldForGroup ? CustomTypeModelFieldForGroupValue<T> : T extends prismicT.CustomTypeModelGroupField ? CustomTypeModelGroupFieldValue<T> : T extends prismicT.CustomTypeModelSliceZoneField ? 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 ? prismicT.SharedSlice : T extends prismicT.SharedSliceModel ? SharedSliceModelValue<T> : T extends prismicT.SharedSliceModelVariation ? SharedSliceModelVariationValue<T> : never;
declare type CustomTypeModelValue<T extends prismicT.CustomTypeModel> = 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];
}>>;
declare type CustomTypeModelFieldForGroupValue<T extends prismicT.CustomTypeModelFieldForGroup> = T extends prismicT.CustomTypeModelBooleanField ? prismicT.BooleanField : T extends prismicT.CustomTypeModelColorField ? prismicT.ColorField : T extends prismicT.CustomTypeModelTitleField ? prismicT.TitleField : T extends prismicT.CustomTypeModelRichTextField ? prismicT.RichTextField : T extends prismicT.CustomTypeModelImageField ? prismicT.ImageField : T extends prismicT.CustomTypeModelLinkField ? prismicT.LinkField : T extends prismicT.CustomTypeModelLinkToMediaField ? prismicT.LinkToMediaField : T extends prismicT.CustomTypeModelContentRelationshipField ? prismicT.RelationField : T extends prismicT.CustomTypeModelDateField ? prismicT.DateField : T extends prismicT.CustomTypeModelTimestampField ? prismicT.TimestampField : T extends prismicT.CustomTypeModelNumberField ? prismicT.NumberField : T extends prismicT.CustomTypeModelKeyTextField ? prismicT.KeyTextField : T extends prismicT.CustomTypeModelSelectField ? prismicT.SelectField : T extends prismicT.CustomTypeModelEmbedField ? prismicT.EmbedField : T extends prismicT.CustomTypeModelGeoPointField ? prismicT.GeoPointField : T extends prismicT.CustomTypeModelIntegrationFieldsField ? prismicT.IntegrationFields : never;
declare type CustomTypeModelGroupFieldValue<T extends prismicT.CustomTypeModelGroupField> = prismicT.GroupField<ModelValueMap<T["config"]["fields"]>>;
declare type CustomTypeModelSliceValue<T extends prismicT.CustomTypeModelSlice> = prismicT.Slice<string, ModelValueMap<T["non-repeat"]>, ModelValueMap<T["repeat"]>>;
declare type CustomTypeModelSliceValue<T extends prismicT.CustomTypeModelSlice, SliceType = string> = prismicT.Slice<SliceType, ModelValueMap<T["non-repeat"]>, ModelValueMap<T["repeat"]>>;
declare type SharedSliceModelValue<T extends prismicT.SharedSliceModel> = prismicT.SharedSlice<T["id"], SharedSliceModelVariationValue<IterableElement<T["variations"]>>>;

@@ -382,3 +320,3 @@ declare type SharedSliceModelVariationValue<T extends prismicT.SharedSliceModelVariation> = prismicT.SharedSlice<string, prismicT.SharedSliceVariation<T["id"], ModelValueMap<T["primary"]>, ModelValueMap<T["items"]>>>;

} & MockRestApiConfig;
declare const query: <Document_1 extends prismicT.PrismicDocument<Record<string, prismicT.AnyRegularField | prismicT.GroupField<Record<string, prismicT.AnyRegularField>> | prismicT.SliceZone<prismicT.Slice<string, Record<string, prismicT.AnyRegularField>, Record<string, prismicT.AnyRegularField>> | prismicT.SharedSlice<string, prismicT.SharedSliceVariation<string, Record<string, prismicT.AnyRegularField>, Record<string, prismicT.AnyRegularField>>>>>, string, string> = prismicT.PrismicDocument<Record<string, prismicT.AnyRegularField | prismicT.GroupField<Record<string, prismicT.AnyRegularField>> | prismicT.SliceZone<prismicT.Slice<string, Record<string, prismicT.AnyRegularField>, Record<string, prismicT.AnyRegularField>> | prismicT.SharedSlice<string, prismicT.SharedSliceVariation<string, Record<string, prismicT.AnyRegularField>, Record<string, prismicT.AnyRegularField>>>>>, string, string>>(config?: MockRestApiQueryConfig<Document_1>) => prismicT.Query<Document_1>;
declare const query: <Document_1 extends prismicT.PrismicDocument<Record<string, any>, string, string> = prismicT.PrismicDocument<Record<string, any>, string, string>>(config?: MockRestApiQueryConfig<Document_1>) => prismicT.Query<Document_1>;

@@ -417,76 +355,22 @@ declare type MockRestApiTagsConfig = MockRestApiConfig;

declare type MockContentRelationshipModelConfig = {
constrainCustomTypes?: boolean;
constrainTags?: boolean;
declare type MockContentRelationshipModelConfig<CustomTypeIDs extends string = string, Tags extends string = string> = {
customTypeIDs?: readonly CustomTypeIDs[];
tags?: readonly Tags[];
} & MockModelConfig;
declare const contentRelationship: (config?: MockContentRelationshipModelConfig) => prismicT.CustomTypeModelContentRelationshipField;
declare const contentRelationship: <CustomTypeIDs extends string, Tags extends string>(config?: MockContentRelationshipModelConfig<CustomTypeIDs, Tags>) => prismicT.CustomTypeModelContentRelationshipField<CustomTypeIDs, Tags>;
declare type MockRichTextModelConfig<WithMultipleBlocks extends boolean = boolean> = {
withMultipleBlocks?: WithMultipleBlocks;
} & MockModelConfig;
declare const richText: <WithMultipleBlocks extends boolean = boolean>(config?: MockRichTextModelConfig<WithMultipleBlocks>) => WithMultipleBlocks extends true ? prismicT.CustomTypeModelRichTextMultiField : prismicT.CustomTypeModelRichTextSingleField;
declare type MockLinkModel<AllowTargetBlank extends boolean = boolean> = prismicT.CustomTypeModelLinkField & {
config: AllowTargetBlank extends true ? {
allowTargetBlank: true;
} : {
allowTargetBlank?: undefined;
};
};
declare type MockLinkModelConfig<AllowTargetBlank extends boolean = boolean> = {
allowTargetBlank?: AllowTargetBlank;
} & MockModelConfig;
declare const link: <AllowTargetBlank extends boolean = boolean>(config?: MockLinkModelConfig<AllowTargetBlank>) => MockLinkModel<AllowTargetBlank>;
declare const mockModelFns: {
readonly boolean: (config?: MockModelConfig) => prismicT.CustomTypeModelBooleanField;
readonly color: (config?: MockModelConfig) => prismicT.CustomTypeModelColorField;
readonly contentRelationship: (config?: MockContentRelationshipModelConfig) => prismicT.CustomTypeModelContentRelationshipField;
readonly date: (config?: MockModelConfig) => prismicT.CustomTypeModelDateField;
readonly embed: (config?: MockModelConfig) => prismicT.CustomTypeModelEmbedField;
readonly geoPoint: (config?: MockModelConfig) => prismicT.CustomTypeModelGeoPointField;
readonly image: (config?: {
withConstraint?: boolean | undefined;
thumbnailsCount?: number | undefined;
} & MockModelConfig) => prismicT.CustomTypeModelImageField;
readonly integrationFields: (config?: MockModelConfig) => prismicT.CustomTypeModelIntegrationFieldsField;
readonly keyText: (config?: MockModelConfig) => prismicT.CustomTypeModelKeyTextField;
readonly link: <AllowTargetBlank extends boolean = boolean>(config?: MockLinkModelConfig<AllowTargetBlank>) => prismicT.CustomTypeModelLinkField & {
config: AllowTargetBlank extends true ? {
allowTargetBlank: true;
} : {
allowTargetBlank?: undefined;
};
};
readonly linkToMedia: (config?: MockModelConfig) => prismicT.CustomTypeModelLinkToMediaField;
readonly number: (config?: MockModelConfig) => prismicT.CustomTypeModelNumberField;
readonly richText: <WithMultipleBlocks extends boolean = boolean>(config?: MockRichTextModelConfig<WithMultipleBlocks>) => WithMultipleBlocks extends true ? prismicT.CustomTypeModelRichTextMultiField : prismicT.CustomTypeModelRichTextSingleField;
readonly select: (config?: {
optionsCount?: number | undefined;
withDefaultValue?: boolean | undefined;
} & MockModelConfig) => prismicT.CustomTypeModelSelectField<string, string>;
readonly timestamp: (config?: MockModelConfig) => prismicT.CustomTypeModelTimestampField;
readonly title: (config?: MockModelConfig) => prismicT.CustomTypeModelRichTextSingleField;
};
declare type MockModelFns = typeof mockModelFns;
declare type BuildMockGroupFieldMapConfig = {
configs?: {
[P in keyof MockModelFns]?: {
count?: number;
config?: Parameters<MockModelFns[P]>[0];
};
};
} & MockModelConfig;
declare type MockCustomTypeModelConfig = {
tabsCount?: number;
withUID?: boolean;
configs?: BuildMockGroupFieldMapConfig["configs"];
declare 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;
declare const customType: (config?: MockCustomTypeModelConfig) => prismicT.CustomTypeModel;
declare 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;
declare const customType: <Definition extends Record<string, prismicT.CustomTypeModelField> | prismicT.CustomTypeModelDefinition<string>>(config?: MockCustomTypeModelConfig<Definition>) => MockCustomTypeModel<Definition>;

@@ -502,10 +386,12 @@ declare type MockDateModelConfig = MockModelConfig;

declare type MockGroupModelConfig = BuildMockGroupFieldMapConfig & MockModelConfig;
declare const group: (config?: MockGroupModelConfig) => prismicT.CustomTypeModelGroupField;
declare type MockGroupModelConfig<Fields extends GroupFieldModelMap> = {
fields?: Fields;
} & MockModelConfig;
declare const group: <Fields extends GroupFieldModelMap>(config?: MockGroupModelConfig<Fields>) => prismicT.CustomTypeModelGroupField<Fields>;
declare type MockImageModelConfig = {
declare type MockImageModelConfig<ThumbnailNames extends string = string> = {
withConstraint?: boolean;
thumbnailsCount?: number;
thumbnailNames?: readonly ThumbnailNames[];
} & MockModelConfig;
declare const image: (config?: MockImageModelConfig) => prismicT.CustomTypeModelImageField;
declare const image: <ThumbnailNames extends string = string>(config?: MockImageModelConfig<ThumbnailNames>) => prismicT.CustomTypeModelImageField<ThumbnailNames>;

@@ -518,2 +404,14 @@ declare type MockIntegrationFieldsModelConfig = MockModelConfig;

declare type MockLinkModel<AllowTargetBlank extends boolean = boolean> = prismicT.CustomTypeModelLinkField & {
config: AllowTargetBlank extends true ? {
allowTargetBlank: true;
} : {
allowTargetBlank?: undefined;
};
};
declare type MockLinkModelConfig<AllowTargetBlank extends boolean = boolean> = {
allowTargetBlank?: AllowTargetBlank;
} & MockModelConfig;
declare const link: <AllowTargetBlank extends boolean = boolean>(config?: MockLinkModelConfig<AllowTargetBlank>) => MockLinkModel<AllowTargetBlank>;
declare type MockLinkTomediaModelConfig = MockModelConfig;

@@ -525,42 +423,41 @@ declare const linkToMedia: (config?: MockLinkTomediaModelConfig) => prismicT.CustomTypeModelLinkToMediaField;

declare type MockSelectModelConfig = {
optionsCount?: number;
withDefaultValue?: boolean;
declare type MockRichTextModelConfig<WithMultipleBlocks extends boolean = boolean> = {
withMultipleBlocks?: WithMultipleBlocks;
} & MockModelConfig;
declare const select: (config?: MockSelectModelConfig) => prismicT.CustomTypeModelSelectField;
declare const richText: <WithMultipleBlocks extends boolean = boolean>(config?: MockRichTextModelConfig<WithMultipleBlocks>) => WithMultipleBlocks extends true ? prismicT.CustomTypeModelRichTextMultiField : prismicT.CustomTypeModelRichTextSingleField;
declare type MockSharedSliceVariationModelConfig = {
primaryFieldConfig?: BuildMockGroupFieldMapConfig;
itemsFieldConfig?: BuildMockGroupFieldMapConfig;
declare type MockSelectModelConfig<Option extends string = string, DefaultOption extends Option = Option> = {
options?: Option[];
defaultValue?: DefaultOption;
} & MockModelConfig;
declare const sharedSliceVariation: (config?: MockSharedSliceVariationModelConfig) => prismicT.SharedSliceModelVariation;
declare const select: <Option extends string, DefaultOption extends Option>(config?: MockSelectModelConfig<Option, DefaultOption>) => prismicT.CustomTypeModelSelectField<Option, DefaultOption>;
declare type MockSharedSliceModelConfig<Variation extends prismicT.SharedSliceModelVariation> = ({
declare type MockSharedSliceModelConfig<Variation extends prismicT.SharedSliceModelVariation> = {
id?: string;
name?: string;
variations?: Variation[];
variationsCount?: never;
} | {
variations?: never;
variationsCount?: number;
}) & Pick<MockSharedSliceVariationModelConfig, "itemsFieldConfig" | "primaryFieldConfig"> & MockModelConfig;
declare const sharedSlice: <Variation extends prismicT.SharedSliceModelVariation<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>>(config?: MockSharedSliceModelConfig<Variation>) => prismicT.SharedSliceModel<string, Variation>;
} & MockModelConfig;
declare const sharedSlice: <Variation extends prismicT.SharedSliceModelVariation<string, Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>>(config?: MockSharedSliceModelConfig<Variation>) => prismicT.SharedSliceModel<string, Variation>;
declare const sharedSliceChoice: () => prismicT.CustomTypeModelSharedSlice;
declare type MockSliceModelConfig = {
repeatFieldConfig?: BuildMockGroupFieldMapConfig;
nonRepeatFieldConfig?: BuildMockGroupFieldMapConfig;
declare type MockSharedSliceVariationModelConfig<ID extends string = string, PrimaryFields extends GroupFieldModelMap = GroupFieldModelMap, ItemsFields extends GroupFieldModelMap = GroupFieldModelMap> = {
id?: ID;
name?: string;
primaryFields?: PrimaryFields;
itemsFields?: ItemsFields;
} & MockModelConfig;
declare const slice: (config?: MockSliceModelConfig) => prismicT.CustomTypeModelSlice;
declare const sharedSliceVariation: <ID extends string, PrimaryFields extends GroupFieldModelMap, ItemsFields extends GroupFieldModelMap>(config?: MockSharedSliceVariationModelConfig<ID, PrimaryFields, ItemsFields>) => prismicT.SharedSliceModelVariation<ID, PrimaryFields, ItemsFields>;
declare type MockSliceZoneModelConfig = ({
choices?: Record<string, prismicT.CustomTypeModelSlice | prismicT.CustomTypeModelSharedSlice>;
choicesCount?: never;
withSharedSlices?: never;
} | {
choices?: never;
choicesCount?: number;
withSharedSlices?: boolean;
}) & MockModelConfig;
declare const sliceZone: (config?: MockSliceZoneModelConfig) => prismicT.CustomTypeModelSliceZoneField;
declare type MockSliceModelConfig<NonRepeatFields extends GroupFieldModelMap = GroupFieldModelMap, RepeatFields extends GroupFieldModelMap = GroupFieldModelMap> = {
nonRepeatFields?: NonRepeatFields;
repeatFields?: RepeatFields;
} & MockModelConfig;
declare const slice: <NonRepeatFields extends GroupFieldModelMap, RepeatFields extends GroupFieldModelMap>(config?: MockSliceModelConfig<NonRepeatFields, RepeatFields>) => prismicT.CustomTypeModelSlice<NonRepeatFields, RepeatFields>;
declare type MockSliceZoneModelConfig<Slices extends Record<string, prismicT.CustomTypeModelSlice | prismicT.CustomTypeModelSharedSlice> = Record<string, prismicT.CustomTypeModelSlice | prismicT.CustomTypeModelSharedSlice>> = {
choices?: Slices;
} & MockModelConfig;
declare const sliceZone: <Slices extends Record<string, prismicT.CustomTypeModelSlice<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>> | prismicT.CustomTypeModelSharedSlice>>(config?: MockSliceZoneModelConfig<Slices>) => prismicT.CustomTypeModelSliceZoneField<Slices>;
declare type MockTimestampModelConfig = MockModelConfig;

@@ -575,2 +472,5 @@ declare const timestamp: (config?: MockTimestampModelConfig) => prismicT.CustomTypeModelTimestampField;

declare type BuildMockGroupFieldMapConfig = MockModelConfig;
declare const buildMockGroupFieldMap: (config?: BuildMockGroupFieldMapConfig) => GroupFieldModelMap;
declare const index_boolean: typeof boolean;

@@ -600,2 +500,3 @@ declare const index_color: typeof color;

declare const index_uid: typeof uid;
declare const index_buildMockGroupFieldMap: typeof buildMockGroupFieldMap;
declare namespace index {

@@ -627,2 +528,3 @@ export {

index_uid as uid,
index_buildMockGroupFieldMap as buildMockGroupFieldMap,
};

@@ -629,0 +531,0 @@ }

172

dist/model/index.d.ts

@@ -7,2 +7,3 @@ import * as prismicT from '@prismicio/types';

};
declare type GroupFieldModelMap = Record<string, prismicT.CustomTypeModelFieldForGroup>;

@@ -15,76 +16,22 @@ declare type MockBooleanModelConfig = MockModelConfig;

declare type MockContentRelationshipModelConfig = {
constrainCustomTypes?: boolean;
constrainTags?: boolean;
declare type MockContentRelationshipModelConfig<CustomTypeIDs extends string = string, Tags extends string = string> = {
customTypeIDs?: readonly CustomTypeIDs[];
tags?: readonly Tags[];
} & MockModelConfig;
declare const contentRelationship: (config?: MockContentRelationshipModelConfig) => prismicT.CustomTypeModelContentRelationshipField;
declare const contentRelationship: <CustomTypeIDs extends string, Tags extends string>(config?: MockContentRelationshipModelConfig<CustomTypeIDs, Tags>) => prismicT.CustomTypeModelContentRelationshipField<CustomTypeIDs, Tags>;
declare type MockRichTextModelConfig<WithMultipleBlocks extends boolean = boolean> = {
withMultipleBlocks?: WithMultipleBlocks;
} & MockModelConfig;
declare const richText: <WithMultipleBlocks extends boolean = boolean>(config?: MockRichTextModelConfig<WithMultipleBlocks>) => WithMultipleBlocks extends true ? prismicT.CustomTypeModelRichTextMultiField : prismicT.CustomTypeModelRichTextSingleField;
declare type MockLinkModel<AllowTargetBlank extends boolean = boolean> = prismicT.CustomTypeModelLinkField & {
config: AllowTargetBlank extends true ? {
allowTargetBlank: true;
} : {
allowTargetBlank?: undefined;
};
};
declare type MockLinkModelConfig<AllowTargetBlank extends boolean = boolean> = {
allowTargetBlank?: AllowTargetBlank;
} & MockModelConfig;
declare const link: <AllowTargetBlank extends boolean = boolean>(config?: MockLinkModelConfig<AllowTargetBlank>) => MockLinkModel<AllowTargetBlank>;
declare const mockModelFns: {
readonly boolean: (config?: MockModelConfig) => prismicT.CustomTypeModelBooleanField;
readonly color: (config?: MockModelConfig) => prismicT.CustomTypeModelColorField;
readonly contentRelationship: (config?: MockContentRelationshipModelConfig) => prismicT.CustomTypeModelContentRelationshipField;
readonly date: (config?: MockModelConfig) => prismicT.CustomTypeModelDateField;
readonly embed: (config?: MockModelConfig) => prismicT.CustomTypeModelEmbedField;
readonly geoPoint: (config?: MockModelConfig) => prismicT.CustomTypeModelGeoPointField;
readonly image: (config?: {
withConstraint?: boolean | undefined;
thumbnailsCount?: number | undefined;
} & MockModelConfig) => prismicT.CustomTypeModelImageField;
readonly integrationFields: (config?: MockModelConfig) => prismicT.CustomTypeModelIntegrationFieldsField;
readonly keyText: (config?: MockModelConfig) => prismicT.CustomTypeModelKeyTextField;
readonly link: <AllowTargetBlank extends boolean = boolean>(config?: MockLinkModelConfig<AllowTargetBlank>) => prismicT.CustomTypeModelLinkField & {
config: AllowTargetBlank extends true ? {
allowTargetBlank: true;
} : {
allowTargetBlank?: undefined;
};
};
readonly linkToMedia: (config?: MockModelConfig) => prismicT.CustomTypeModelLinkToMediaField;
readonly number: (config?: MockModelConfig) => prismicT.CustomTypeModelNumberField;
readonly richText: <WithMultipleBlocks extends boolean = boolean>(config?: MockRichTextModelConfig<WithMultipleBlocks>) => WithMultipleBlocks extends true ? prismicT.CustomTypeModelRichTextMultiField : prismicT.CustomTypeModelRichTextSingleField;
readonly select: (config?: {
optionsCount?: number | undefined;
withDefaultValue?: boolean | undefined;
} & MockModelConfig) => prismicT.CustomTypeModelSelectField<string, string>;
readonly timestamp: (config?: MockModelConfig) => prismicT.CustomTypeModelTimestampField;
readonly title: (config?: MockModelConfig) => prismicT.CustomTypeModelRichTextSingleField;
};
declare type MockModelFns = typeof mockModelFns;
declare type BuildMockGroupFieldMapConfig = {
configs?: {
[P in keyof MockModelFns]?: {
count?: number;
config?: Parameters<MockModelFns[P]>[0];
};
};
} & MockModelConfig;
declare type MockCustomTypeModelConfig = {
tabsCount?: number;
withUID?: boolean;
configs?: BuildMockGroupFieldMapConfig["configs"];
declare 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;
declare const customType: (config?: MockCustomTypeModelConfig) => prismicT.CustomTypeModel;
declare 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;
declare const customType: <Definition extends Record<string, prismicT.CustomTypeModelField> | prismicT.CustomTypeModelDefinition<string>>(config?: MockCustomTypeModelConfig<Definition>) => MockCustomTypeModel<Definition>;

@@ -100,10 +47,12 @@ declare type MockDateModelConfig = MockModelConfig;

declare type MockGroupModelConfig = BuildMockGroupFieldMapConfig & MockModelConfig;
declare const group: (config?: MockGroupModelConfig) => prismicT.CustomTypeModelGroupField;
declare type MockGroupModelConfig<Fields extends GroupFieldModelMap> = {
fields?: Fields;
} & MockModelConfig;
declare const group: <Fields extends GroupFieldModelMap>(config?: MockGroupModelConfig<Fields>) => prismicT.CustomTypeModelGroupField<Fields>;
declare type MockImageModelConfig = {
declare type MockImageModelConfig<ThumbnailNames extends string = string> = {
withConstraint?: boolean;
thumbnailsCount?: number;
thumbnailNames?: readonly ThumbnailNames[];
} & MockModelConfig;
declare const image: (config?: MockImageModelConfig) => prismicT.CustomTypeModelImageField;
declare const image: <ThumbnailNames extends string = string>(config?: MockImageModelConfig<ThumbnailNames>) => prismicT.CustomTypeModelImageField<ThumbnailNames>;

@@ -116,2 +65,14 @@ declare type MockIntegrationFieldsModelConfig = MockModelConfig;

declare type MockLinkModel<AllowTargetBlank extends boolean = boolean> = prismicT.CustomTypeModelLinkField & {
config: AllowTargetBlank extends true ? {
allowTargetBlank: true;
} : {
allowTargetBlank?: undefined;
};
};
declare type MockLinkModelConfig<AllowTargetBlank extends boolean = boolean> = {
allowTargetBlank?: AllowTargetBlank;
} & MockModelConfig;
declare const link: <AllowTargetBlank extends boolean = boolean>(config?: MockLinkModelConfig<AllowTargetBlank>) => MockLinkModel<AllowTargetBlank>;
declare type MockLinkTomediaModelConfig = MockModelConfig;

@@ -123,42 +84,41 @@ declare const linkToMedia: (config?: MockLinkTomediaModelConfig) => prismicT.CustomTypeModelLinkToMediaField;

declare type MockSelectModelConfig = {
optionsCount?: number;
withDefaultValue?: boolean;
declare type MockRichTextModelConfig<WithMultipleBlocks extends boolean = boolean> = {
withMultipleBlocks?: WithMultipleBlocks;
} & MockModelConfig;
declare const select: (config?: MockSelectModelConfig) => prismicT.CustomTypeModelSelectField;
declare const richText: <WithMultipleBlocks extends boolean = boolean>(config?: MockRichTextModelConfig<WithMultipleBlocks>) => WithMultipleBlocks extends true ? prismicT.CustomTypeModelRichTextMultiField : prismicT.CustomTypeModelRichTextSingleField;
declare type MockSharedSliceVariationModelConfig = {
primaryFieldConfig?: BuildMockGroupFieldMapConfig;
itemsFieldConfig?: BuildMockGroupFieldMapConfig;
declare type MockSelectModelConfig<Option extends string = string, DefaultOption extends Option = Option> = {
options?: Option[];
defaultValue?: DefaultOption;
} & MockModelConfig;
declare const sharedSliceVariation: (config?: MockSharedSliceVariationModelConfig) => prismicT.SharedSliceModelVariation;
declare const select: <Option extends string, DefaultOption extends Option>(config?: MockSelectModelConfig<Option, DefaultOption>) => prismicT.CustomTypeModelSelectField<Option, DefaultOption>;
declare type MockSharedSliceModelConfig<Variation extends prismicT.SharedSliceModelVariation> = ({
declare type MockSharedSliceModelConfig<Variation extends prismicT.SharedSliceModelVariation> = {
id?: string;
name?: string;
variations?: Variation[];
variationsCount?: never;
} | {
variations?: never;
variationsCount?: number;
}) & Pick<MockSharedSliceVariationModelConfig, "itemsFieldConfig" | "primaryFieldConfig"> & MockModelConfig;
declare const sharedSlice: <Variation extends prismicT.SharedSliceModelVariation<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>>(config?: MockSharedSliceModelConfig<Variation>) => prismicT.SharedSliceModel<string, Variation>;
} & MockModelConfig;
declare const sharedSlice: <Variation extends prismicT.SharedSliceModelVariation<string, Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>>(config?: MockSharedSliceModelConfig<Variation>) => prismicT.SharedSliceModel<string, Variation>;
declare const sharedSliceChoice: () => prismicT.CustomTypeModelSharedSlice;
declare type MockSliceModelConfig = {
repeatFieldConfig?: BuildMockGroupFieldMapConfig;
nonRepeatFieldConfig?: BuildMockGroupFieldMapConfig;
declare type MockSharedSliceVariationModelConfig<ID extends string = string, PrimaryFields extends GroupFieldModelMap = GroupFieldModelMap, ItemsFields extends GroupFieldModelMap = GroupFieldModelMap> = {
id?: ID;
name?: string;
primaryFields?: PrimaryFields;
itemsFields?: ItemsFields;
} & MockModelConfig;
declare const slice: (config?: MockSliceModelConfig) => prismicT.CustomTypeModelSlice;
declare const sharedSliceVariation: <ID extends string, PrimaryFields extends GroupFieldModelMap, ItemsFields extends GroupFieldModelMap>(config?: MockSharedSliceVariationModelConfig<ID, PrimaryFields, ItemsFields>) => prismicT.SharedSliceModelVariation<ID, PrimaryFields, ItemsFields>;
declare type MockSliceZoneModelConfig = ({
choices?: Record<string, prismicT.CustomTypeModelSlice | prismicT.CustomTypeModelSharedSlice>;
choicesCount?: never;
withSharedSlices?: never;
} | {
choices?: never;
choicesCount?: number;
withSharedSlices?: boolean;
}) & MockModelConfig;
declare const sliceZone: (config?: MockSliceZoneModelConfig) => prismicT.CustomTypeModelSliceZoneField;
declare type MockSliceModelConfig<NonRepeatFields extends GroupFieldModelMap = GroupFieldModelMap, RepeatFields extends GroupFieldModelMap = GroupFieldModelMap> = {
nonRepeatFields?: NonRepeatFields;
repeatFields?: RepeatFields;
} & MockModelConfig;
declare const slice: <NonRepeatFields extends GroupFieldModelMap, RepeatFields extends GroupFieldModelMap>(config?: MockSliceModelConfig<NonRepeatFields, RepeatFields>) => prismicT.CustomTypeModelSlice<NonRepeatFields, RepeatFields>;
declare type MockSliceZoneModelConfig<Slices extends Record<string, prismicT.CustomTypeModelSlice | prismicT.CustomTypeModelSharedSlice> = Record<string, prismicT.CustomTypeModelSlice | prismicT.CustomTypeModelSharedSlice>> = {
choices?: Slices;
} & MockModelConfig;
declare const sliceZone: <Slices extends Record<string, prismicT.CustomTypeModelSlice<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>> | prismicT.CustomTypeModelSharedSlice>>(config?: MockSliceZoneModelConfig<Slices>) => prismicT.CustomTypeModelSliceZoneField<Slices>;
declare type MockTimestampModelConfig = MockModelConfig;

@@ -173,2 +133,6 @@ declare const timestamp: (config?: MockTimestampModelConfig) => prismicT.CustomTypeModelTimestampField;

export { boolean, color, contentRelationship, customType, date, embed, geoPoint, group, image, integrationFields, keyText, link, linkToMedia, number, richText, select, sharedSlice, sharedSliceChoice, sharedSliceVariation, slice, sliceZone, timestamp, title, uid };
declare type BuildMockGroupFieldMapConfig = MockModelConfig;
declare const buildMockGroupFieldMap: (config?: BuildMockGroupFieldMapConfig) => GroupFieldModelMap;
export { boolean, buildMockGroupFieldMap, color, contentRelationship, customType, date, embed, geoPoint, group, image, integrationFields, keyText, link, linkToMedia, number, richText, select, sharedSlice, sharedSliceChoice, sharedSliceVariation, slice, sliceZone, timestamp, title, uid };
//# sourceMappingURL=index.d.ts.map

170

dist/value/index.d.ts
import * as prismicT from '@prismicio/types';
declare type IterableElement<TargetIterable> = TargetIterable extends Iterable<infer ElementType> ? ElementType : TargetIterable extends AsyncIterable<infer ElementType> ? ElementType : never;
declare type ValueOf<ObjectType, ValueType extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType];
declare type ValueOf<ObjectType extends Record<string, unknown>> = ObjectType[string];
declare type Seed = string | number | number[];

@@ -11,2 +11,5 @@ declare type PrismicModel = prismicT.CustomTypeModel | prismicT.CustomTypeModelField | prismicT.CustomTypeModelSlice | prismicT.SharedSliceModel | prismicT.SharedSliceModelVariation;

};
declare type MockValueStateConfig<State extends prismicT.FieldState = prismicT.FieldState> = {
state?: State;
};
declare type CustomTypeModelStructuredTextField = prismicT.CustomTypeModelRichTextField | prismicT.CustomTypeModelTitleField;

@@ -20,7 +23,11 @@ declare type MockRichTextValueConfig$1<Model extends CustomTypeModelStructuredTextField = CustomTypeModelStructuredTextField> = {

};
declare type ModelValue<T extends PrismicModel> = T extends prismicT.CustomTypeModel ? CustomTypeModelValue<T> : T extends prismicT.CustomTypeModelUIDField ? prismicT.PrismicDocument["uid"] : T extends prismicT.CustomTypeModelFieldForGroup ? CustomTypeModelFieldForGroupValue<T> : T extends prismicT.CustomTypeModelGroupField ? CustomTypeModelGroupFieldValue<T> : T extends prismicT.CustomTypeModelSliceZoneField ? prismicT.SliceZone : T extends prismicT.CustomTypeModelSlice ? CustomTypeModelSliceValue<T> : T extends prismicT.CustomTypeModelSharedSlice ? prismicT.SharedSlice : T extends prismicT.SharedSliceModel ? SharedSliceModelValue<T> : T extends prismicT.SharedSliceModelVariation ? SharedSliceModelVariationValue<T> : never;
declare type CustomTypeModelValue<T extends prismicT.CustomTypeModel> = prismicT.PrismicDocument<ModelValueMap<ValueOf<T["json"]>>>;
declare type ModelValue<T extends PrismicModel> = T extends prismicT.CustomTypeModel ? CustomTypeModelValue<T> : T extends prismicT.CustomTypeModelUIDField ? prismicT.PrismicDocument["uid"] : T extends prismicT.CustomTypeModelFieldForGroup ? CustomTypeModelFieldForGroupValue<T> : T extends prismicT.CustomTypeModelGroupField ? CustomTypeModelGroupFieldValue<T> : T extends prismicT.CustomTypeModelSliceZoneField ? 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 ? prismicT.SharedSlice : T extends prismicT.SharedSliceModel ? SharedSliceModelValue<T> : T extends prismicT.SharedSliceModelVariation ? SharedSliceModelVariationValue<T> : never;
declare type CustomTypeModelValue<T extends prismicT.CustomTypeModel> = 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];
}>>;
declare type CustomTypeModelFieldForGroupValue<T extends prismicT.CustomTypeModelFieldForGroup> = T extends prismicT.CustomTypeModelBooleanField ? prismicT.BooleanField : T extends prismicT.CustomTypeModelColorField ? prismicT.ColorField : T extends prismicT.CustomTypeModelTitleField ? prismicT.TitleField : T extends prismicT.CustomTypeModelRichTextField ? prismicT.RichTextField : T extends prismicT.CustomTypeModelImageField ? prismicT.ImageField : T extends prismicT.CustomTypeModelLinkField ? prismicT.LinkField : T extends prismicT.CustomTypeModelLinkToMediaField ? prismicT.LinkToMediaField : T extends prismicT.CustomTypeModelContentRelationshipField ? prismicT.RelationField : T extends prismicT.CustomTypeModelDateField ? prismicT.DateField : T extends prismicT.CustomTypeModelTimestampField ? prismicT.TimestampField : T extends prismicT.CustomTypeModelNumberField ? prismicT.NumberField : T extends prismicT.CustomTypeModelKeyTextField ? prismicT.KeyTextField : T extends prismicT.CustomTypeModelSelectField ? prismicT.SelectField : T extends prismicT.CustomTypeModelEmbedField ? prismicT.EmbedField : T extends prismicT.CustomTypeModelGeoPointField ? prismicT.GeoPointField : T extends prismicT.CustomTypeModelIntegrationFieldsField ? prismicT.IntegrationFields : never;
declare type CustomTypeModelGroupFieldValue<T extends prismicT.CustomTypeModelGroupField> = prismicT.GroupField<ModelValueMap<T["config"]["fields"]>>;
declare type CustomTypeModelSliceValue<T extends prismicT.CustomTypeModelSlice> = prismicT.Slice<string, ModelValueMap<T["non-repeat"]>, ModelValueMap<T["repeat"]>>;
declare type CustomTypeModelSliceValue<T extends prismicT.CustomTypeModelSlice, SliceType = string> = prismicT.Slice<SliceType, ModelValueMap<T["non-repeat"]>, ModelValueMap<T["repeat"]>>;
declare type SharedSliceModelValue<T extends prismicT.SharedSliceModel> = prismicT.SharedSlice<T["id"], SharedSliceModelVariationValue<IterableElement<T["variations"]>>>;

@@ -61,7 +68,6 @@ declare type SharedSliceModelVariationValue<T extends prismicT.SharedSliceModelVariation> = prismicT.SharedSlice<string, prismicT.SharedSliceVariation<T["id"], ModelValueMap<T["primary"]>, ModelValueMap<T["items"]>>>;

declare type MockColorValueConfig<Model extends prismicT.CustomTypeModelColorField = prismicT.CustomTypeModelColorField> = MockValueConfig<Model>;
declare const color: (config?: MockColorValueConfig) => prismicT.ColorField;
declare type MockColorValueConfig<Model extends prismicT.CustomTypeModelColorField = prismicT.CustomTypeModelColorField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
declare const color: <Model extends prismicT.CustomTypeModelColorField = prismicT.CustomTypeModelColorField, State extends prismicT.FieldState = "filled">(config?: MockColorValueConfig<Model, State>) => prismicT.ColorField<State>;
declare type MockContentRelationshipValueConfig<IsFilled extends boolean = boolean, Model extends prismicT.CustomTypeModelContentRelationshipField = prismicT.CustomTypeModelContentRelationshipField> = {
isFilled?: IsFilled;
declare type MockContentRelationshipValueConfig<Model extends prismicT.CustomTypeModelContentRelationshipField = prismicT.CustomTypeModelContentRelationshipField, State extends prismicT.FieldState = prismicT.FieldState> = {
/**

@@ -71,37 +77,22 @@ * A list of potential documents to which the field can be linked.

linkableDocuments?: prismicT.PrismicDocument[];
} & MockValueConfig<Model>;
declare type MockContentRelationshipValue<IsFilled extends boolean = boolean> = IsFilled extends true ? prismicT.FilledLinkToDocumentField : prismicT.EmptyLinkField<prismicT.LinkType.Document>;
declare const contentRelationship: <IsFilled extends boolean = true, Model extends prismicT.CustomTypeModelContentRelationshipField = prismicT.CustomTypeModelContentRelationshipField>(config?: MockContentRelationshipValueConfig<IsFilled, Model>) => MockContentRelationshipValue<IsFilled>;
} & MockValueConfig<Model> & MockValueStateConfig<State>;
declare const contentRelationship: <Model extends prismicT.CustomTypeModelContentRelationshipField<string, string> = prismicT.CustomTypeModelContentRelationshipField<string, string>, State extends prismicT.FieldState = "filled">(config?: MockContentRelationshipValueConfig<Model, State>) => prismicT.RelationField<Model["config"]["customtypes"], string, never, State>;
declare type MockTimestampValueConfig<Model extends prismicT.CustomTypeModelTimestampField = prismicT.CustomTypeModelTimestampField> = {
declare type MockTimestampValueConfig<Model extends prismicT.CustomTypeModelTimestampField = prismicT.CustomTypeModelTimestampField, State extends prismicT.FieldState = prismicT.FieldState> = {
after?: Date;
before?: Date;
} & MockValueConfig<Model>;
declare const timestamp: (config?: MockTimestampValueConfig) => prismicT.TimestampField;
} & MockValueConfig<Model> & MockValueStateConfig<State>;
declare const timestamp: <Model extends prismicT.CustomTypeModelTimestampField = prismicT.CustomTypeModelTimestampField, State extends prismicT.FieldState = "filled">(config?: MockTimestampValueConfig<Model, State>) => prismicT.TimestampField<State>;
declare type MockDateValueConfig<Model extends prismicT.CustomTypeModelDateField = prismicT.CustomTypeModelDateField> = Pick<MockTimestampValueConfig, "after" | "before"> & MockValueConfig<Model>;
declare const date: (config?: MockDateValueConfig) => prismicT.DateField;
declare type MockDateValueConfig<Model extends prismicT.CustomTypeModelDateField = prismicT.CustomTypeModelDateField, State extends prismicT.FieldState = prismicT.FieldState> = Pick<MockTimestampValueConfig, "after" | "before"> & MockValueConfig<Model> & MockValueStateConfig<State>;
declare const date: <Model extends prismicT.CustomTypeModelDateField = prismicT.CustomTypeModelDateField, State extends prismicT.FieldState = "filled">(config?: MockDateValueConfig<Model, State>) => prismicT.DateField<State>;
declare type MockEmbedValueConfig<Model extends prismicT.CustomTypeModelEmbedField = prismicT.CustomTypeModelEmbedField> = MockValueConfig<Model>;
declare const embed: (config?: MockEmbedValueConfig) => prismicT.EmbedField;
declare type MockEmbedValueConfig<Model extends prismicT.CustomTypeModelEmbedField = prismicT.CustomTypeModelEmbedField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
declare const embed: <Model extends prismicT.CustomTypeModelEmbedField = prismicT.CustomTypeModelEmbedField, State extends prismicT.FieldState = "filled">(config?: MockEmbedValueConfig<Model, State>) => prismicT.EmbedField<prismicT.AnyOEmbed & prismicT.OEmbedExtra, State>;
declare type MockGeoPointValueConfig<Model extends prismicT.CustomTypeModelGeoPointField = prismicT.CustomTypeModelGeoPointField> = MockValueConfig<Model>;
declare const geoPoint: (config?: MockGeoPointValueConfig) => prismicT.GeoPointField;
declare type MockGeoPointValueConfig<Model extends prismicT.CustomTypeModelGeoPointField = prismicT.CustomTypeModelGeoPointField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
declare const geoPoint: <Model extends prismicT.CustomTypeModelGeoPointField = prismicT.CustomTypeModelGeoPointField, State extends prismicT.FieldState = "filled">(config?: MockGeoPointValueConfig<Model, State>) => prismicT.GeoPointField<State>;
declare const patterns$5: {
readonly short: {
readonly minItems: 1;
readonly maxItems: 3;
};
readonly medium: {
readonly minItems: 3;
readonly maxItems: 6;
};
readonly long: {
readonly minItems: 6;
readonly maxItems: 12;
};
};
declare type MockGroupValueConfig<Model extends prismicT.CustomTypeModelGroupField = prismicT.CustomTypeModelGroupField> = {
pattern?: keyof typeof patterns$5;
itemsCount?: number;
configs?: ValueForModelMapConfigs;

@@ -111,16 +102,15 @@ } & MockValueConfig<Model>;

declare type MockImageValueConfig<Model extends prismicT.CustomTypeModelImageField = prismicT.CustomTypeModelImageField> = MockValueConfig<Model>;
declare const image: (config?: MockImageValueConfig) => prismicT.ImageField;
declare type MockImageValueConfig<Model extends prismicT.CustomTypeModelImageField = prismicT.CustomTypeModelImageField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
declare const image: <Model extends prismicT.CustomTypeModelImageField<string> = prismicT.CustomTypeModelImageField<string>, State extends prismicT.FieldState = "filled">(config?: MockImageValueConfig<Model, State>) => prismicT.ImageField<Model["config"]["thumbnails"][number]["name"], State>;
declare type MockIntegrationFieldsValueConfig<Model extends prismicT.CustomTypeModelIntegrationFieldsField = prismicT.CustomTypeModelIntegrationFieldsField, Blob extends unknown = unknown> = {
declare type MockIntegrationFieldsValueConfig<Model extends prismicT.CustomTypeModelIntegrationFieldsField = prismicT.CustomTypeModelIntegrationFieldsField, Blob = unknown, State extends prismicT.FieldState = prismicT.FieldState> = {
data?: Blob;
} & MockValueConfig<Model>;
declare const integrationFields: <Model extends prismicT.CustomTypeModelIntegrationFieldsField = prismicT.CustomTypeModelIntegrationFieldsField, Blob_1 extends unknown = unknown>(config?: MockIntegrationFieldsValueConfig<Model, Blob_1>) => prismicT.IntegrationFields<Blob_1>;
} & MockValueConfig<Model> & MockValueStateConfig<State>;
declare const integrationFields: <Model extends prismicT.CustomTypeModelIntegrationFieldsField = prismicT.CustomTypeModelIntegrationFieldsField, Blob_1 = unknown, State extends prismicT.FieldState = "filled">(config?: MockIntegrationFieldsValueConfig<Model, Blob_1, State>) => prismicT.IntegrationFields<Blob_1, State>;
declare type MockKeyTextValueConfig<Model extends prismicT.CustomTypeModelKeyTextField = prismicT.CustomTypeModelKeyTextField> = MockValueConfig<Model>;
declare const keyText: (config?: MockKeyTextValueConfig) => prismicT.KeyTextField;
declare type MockKeyTextValueConfig<Model extends prismicT.CustomTypeModelKeyTextField = prismicT.CustomTypeModelKeyTextField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
declare const keyText: <Model extends prismicT.CustomTypeModelKeyTextField = prismicT.CustomTypeModelKeyTextField, State extends prismicT.FieldState = "filled">(config?: MockKeyTextValueConfig<Model, State>) => prismicT.KeyTextField<State>;
declare type MockLinkValueConfig<LinkType extends prismicT.LinkType = prismicT.LinkType, IsFilled extends boolean = true, Model extends prismicT.CustomTypeModelLinkField = prismicT.CustomTypeModelLinkField> = {
declare type MockLinkValueConfig<LinkType extends typeof prismicT.LinkType[keyof typeof prismicT.LinkType] = typeof prismicT.LinkType[keyof typeof prismicT.LinkType], Model extends prismicT.CustomTypeModelLinkField = prismicT.CustomTypeModelLinkField, State extends prismicT.FieldState = prismicT.FieldState> = {
type?: LinkType;
isFilled?: IsFilled;
withTargetBlank?: Model["config"]["allowTargetBlank"] extends undefined ? false : boolean;

@@ -130,17 +120,14 @@ /**

*/
linkableDocuments?: LinkType extends prismicT.LinkType.Document ? prismicT.PrismicDocument[] : never;
} & MockValueConfig<Model>;
declare type MockLinkValue<LinkType extends prismicT.LinkType = prismicT.LinkType, IsFilled extends boolean = true> = IsFilled extends true ? LinkType extends prismicT.LinkType.Web ? prismicT.FilledLinkToWebField : LinkType extends prismicT.LinkType.Media ? prismicT.FilledLinkToMediaField : LinkType extends prismicT.LinkType.Document ? prismicT.FilledLinkToDocumentField : never : prismicT.EmptyLinkField<LinkType>;
declare const link: <LinkType extends prismicT.LinkType = prismicT.LinkType, IsFilled extends boolean = true, Model extends prismicT.CustomTypeModelLinkField = prismicT.CustomTypeModelLinkField>(config?: MockLinkValueConfig<LinkType, IsFilled, Model>) => MockLinkValue<LinkType, IsFilled>;
linkableDocuments?: LinkType extends typeof prismicT.LinkType.Document ? prismicT.PrismicDocument[] : never;
} & MockValueConfig<Model> & MockValueStateConfig<State>;
declare type MockLinkValue<LinkType extends typeof prismicT.LinkType[keyof typeof prismicT.LinkType] = typeof prismicT.LinkType[keyof typeof prismicT.LinkType], State extends prismicT.FieldState = "filled"> = State extends "empty" ? prismicT.EmptyLinkField<LinkType> : LinkType extends typeof prismicT.LinkType.Web ? prismicT.FilledLinkToWebField : LinkType extends typeof prismicT.LinkType.Media ? prismicT.FilledLinkToMediaField : LinkType extends typeof prismicT.LinkType.Document ? prismicT.FilledLinkToDocumentField : never;
declare const link: <LinkType extends "Any" | "Document" | "Media" | "Web" = "Any" | "Document" | "Media" | "Web", Model extends prismicT.CustomTypeModelLinkField = prismicT.CustomTypeModelLinkField, State extends prismicT.FieldState = "filled">(config?: MockLinkValueConfig<LinkType, Model, State>) => MockLinkValue<LinkType, State>;
declare type MockLinkToMediaValueConfig<IsFilled extends boolean = true, Model extends prismicT.CustomTypeModelLinkToMediaField = prismicT.CustomTypeModelLinkToMediaField> = {
isFilled?: IsFilled;
} & MockValueConfig<Model>;
declare type MockLinkToMediaValue<IsFilled extends boolean = true> = IsFilled extends true ? prismicT.FilledLinkToMediaField : prismicT.EmptyLinkField<prismicT.LinkType.Media>;
declare const linkToMedia: <IsFilled extends boolean = true, Model extends prismicT.CustomTypeModelLinkToMediaField = prismicT.CustomTypeModelLinkToMediaField>(config?: MockLinkToMediaValueConfig<IsFilled, Model>) => MockLinkToMediaValue<IsFilled>;
declare type MockLinkToMediaValueConfig<Model extends prismicT.CustomTypeModelLinkToMediaField = prismicT.CustomTypeModelLinkToMediaField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
declare const linkToMedia: <Model extends prismicT.CustomTypeModelLinkToMediaField = prismicT.CustomTypeModelLinkToMediaField, State extends prismicT.FieldState = "filled">(config?: MockLinkToMediaValueConfig<Model, State>) => prismicT.LinkToMediaField<State>;
declare type MockNumberValueConfig<Model extends prismicT.CustomTypeModelNumberField = prismicT.CustomTypeModelNumberField> = MockValueConfig<Model>;
declare const number: (config?: MockNumberValueConfig) => prismicT.NumberField;
declare type MockNumberValueConfig<Model extends prismicT.CustomTypeModelNumberField = prismicT.CustomTypeModelNumberField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
declare const number: <Model extends prismicT.CustomTypeModelNumberField = prismicT.CustomTypeModelNumberField, State extends prismicT.FieldState = "filled">(config?: MockNumberValueConfig<Model, State>) => prismicT.NumberField<State>;
declare const patterns$4: {
declare const patterns$1: {
readonly short: {

@@ -160,31 +147,13 @@ readonly blockCountMin: 1;

declare type MockRichTextValueConfig = {
pattern?: keyof typeof patterns$4;
pattern?: keyof typeof patterns$1;
} & MockRichTextValueConfig$1<prismicT.CustomTypeModelRichTextField>;
declare const richText: (config?: MockRichTextValueConfig) => prismicT.RichTextField;
declare type MockSelectValueConfig<Model extends prismicT.CustomTypeModelSelectField = prismicT.CustomTypeModelSelectField> = MockValueConfig<Model>;
declare const select: (config?: MockSelectValueConfig) => prismicT.SelectField;
declare type MockSelectValueConfig<Model extends prismicT.CustomTypeModelSelectField = prismicT.CustomTypeModelSelectField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
declare const select: <Model extends prismicT.CustomTypeModelSelectField<string, string> = prismicT.CustomTypeModelSelectField<string, string>, State extends prismicT.FieldState = "filled">(config?: MockSelectValueConfig<Model, State>) => prismicT.SelectField<Model["config"]["options"][number], State>;
declare const patterns$3: {
readonly none: {
readonly minItems: 0;
readonly maxItems: 0;
};
readonly short: {
readonly minItems: 1;
readonly maxItems: 3;
};
readonly medium: {
readonly minItems: 3;
readonly maxItems: 6;
};
readonly long: {
readonly minItems: 6;
readonly maxItems: 12;
};
};
declare type MockSliceValueConfig<Model extends prismicT.CustomTypeModelSlice = prismicT.CustomTypeModelSlice> = {
type?: string;
label?: string | null;
pattern?: keyof typeof patterns$3;
itemsCount?: number;
primaryFieldConfigs?: ValueForModelMapConfigs;

@@ -195,19 +164,5 @@ itemsFieldConfigs?: ValueForModelMapConfigs;

declare const patterns$2: {
readonly short: {
readonly minItems: 1;
readonly maxItems: 3;
};
readonly medium: {
readonly minItems: 3;
readonly maxItems: 6;
};
readonly long: {
readonly minItems: 6;
readonly maxItems: 12;
};
};
declare type MockSliceZoneValueConfig<Model extends prismicT.CustomTypeModelSliceZoneField = prismicT.CustomTypeModelSliceZoneField> = {
sharedSliceModels?: prismicT.SharedSliceModel[];
pattern?: keyof typeof patterns$2;
itemsCount?: number;
primaryFieldConfigs?: ValueForModelMapConfigs;

@@ -218,31 +173,13 @@ itemsFieldConfigs?: ValueForModelMapConfigs;

declare const patterns$1: {
readonly none: {
readonly minItems: 0;
readonly maxItems: 0;
};
readonly short: {
readonly minItems: 1;
readonly maxItems: 3;
};
readonly medium: {
readonly minItems: 3;
readonly maxItems: 6;
};
readonly long: {
readonly minItems: 6;
readonly maxItems: 12;
};
};
declare type MockSharedSliceVariationValueConfig<Model extends prismicT.SharedSliceModelVariation = prismicT.SharedSliceModelVariation> = {
type?: string;
label?: string;
pattern?: keyof typeof patterns$1;
itemsCount?: number;
primaryFieldConfigs?: ValueForModelMapConfigs;
itemsFieldConfigs?: ValueForModelMapConfigs;
} & MockValueConfig<Model>;
declare const sharedSliceVariation: <Model extends prismicT.SharedSliceModelVariation<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>> = prismicT.SharedSliceModelVariation<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>>(config?: MockSharedSliceVariationValueConfig<Model>) => ModelValue<Model>;
declare const sharedSliceVariation: <Model extends prismicT.SharedSliceModelVariation<string, Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>> = prismicT.SharedSliceModelVariation<string, Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>>(config?: MockSharedSliceVariationValueConfig<Model>) => ModelValue<Model>;
declare type MockSharedSliceValueConfig<Model extends prismicT.SharedSliceModel = prismicT.SharedSliceModel> = Pick<MockSharedSliceVariationValueConfig, "pattern" | "primaryFieldConfigs" | "itemsFieldConfigs"> & MockValueConfig<Model>;
declare const sharedSlice: <Model extends prismicT.SharedSliceModel<string, prismicT.SharedSliceModelVariation<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>> = prismicT.SharedSliceModel<string, prismicT.SharedSliceModelVariation<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>>>(config?: MockSharedSliceValueConfig<Model>) => ModelValue<Model>;
declare type MockSharedSliceValueConfig<Model extends prismicT.SharedSliceModel = prismicT.SharedSliceModel> = Pick<MockSharedSliceVariationValueConfig, "itemsCount" | "primaryFieldConfigs" | "itemsFieldConfigs"> & MockValueConfig<Model>;
declare const sharedSlice: <Model extends prismicT.SharedSliceModel<string, prismicT.SharedSliceModelVariation<string, Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>> = prismicT.SharedSliceModel<string, prismicT.SharedSliceModelVariation<string, Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>>>(config?: MockSharedSliceValueConfig<Model>) => ModelValue<Model>;

@@ -273,4 +210,5 @@ declare const patterns: {

declare type MockUIDValueConfig<Model extends prismicT.CustomTypeModelUIDField = prismicT.CustomTypeModelUIDField> = MockValueConfig<Model>;
declare const uid: (config?: MockUIDValueConfig) => prismicT.PrismicDocument["uid"];
declare const uid: (config?: MockUIDValueConfig) => NonNullable<prismicT.PrismicDocument["uid"]>;
export { MockBooleanValueConfig, MockColorValueConfig, MockContentRelationshipValueConfig, MockCustomTypeValueConfig, MockDateValueConfig, MockCustomTypeValueConfig as MockDocumentValueConfig, MockEmbedValueConfig, MockGeoPointValueConfig, MockGroupValueConfig, MockImageValueConfig, MockIntegrationFieldsValueConfig, MockKeyTextValueConfig, MockLinkToMediaValueConfig, MockLinkValueConfig, MockNumberValueConfig, MockRichTextValueConfig, MockSelectValueConfig, MockSharedSliceValueConfig, MockSharedSliceVariationValueConfig, MockSliceValueConfig, MockSliceZoneValueConfig, MockTimestampValueConfig, MockTitleValueConfig, MockUIDValueConfig, boolean, color, contentRelationship, customType, date, customType as document, embed, geoPoint, group, image, integrationFields, keyText, link, linkToMedia, number, richText, select, sharedSlice, sharedSliceVariation, slice, sliceZone, timestamp, title, uid };
//# sourceMappingURL=index.d.ts.map

42

package.json
{
"name": "@prismicio/mock",
"version": "0.0.6",
"version": "0.0.7",
"description": "Generate mock Prismic documents, fields, Slices, and models for development and testing environments",

@@ -23,15 +23,15 @@ "keywords": [

"require": "./dist/index.cjs",
"import": "./dist/index.mjs"
"import": "./dist/index.js"
},
"./api": {
"require": "./dist/api/index.cjs",
"import": "./dist/api/index.mjs"
"import": "./dist/api/index.js"
},
"./model": {
"require": "./dist/model/index.cjs",
"import": "./dist/model/index.mjs"
"import": "./dist/model/index.js"
},
"./value": {
"require": "./dist/value/index.cjs",
"import": "./dist/value/index.mjs"
"import": "./dist/value/index.js"
},

@@ -41,3 +41,3 @@ "./package.json": "./package.json"

"main": "dist/index.cjs",
"module": "dist/index.mjs",
"module": "dist/index.js",
"types": "dist/index.d.ts",

@@ -52,13 +52,13 @@ "files": [

"format": "prettier --write .",
"lint": "eslint --ext .js,.ts .",
"prepare": "npm run build",
"release": "npm run build && npm run test && standard-version && git push --follow-tags && npm run build && npm publish",
"release:dry": "standard-version --dry-run",
"release:alpha": "npm run build && npm run test && standard-version --release-as major --prerelease alpha && git push --follow-tags && npm run build && npm publish --tag alpha",
"release:alpha:dry": "standard-version --release-as major --prerelease alpha --dry-run",
"lint": "eslint --ext .js,.ts .",
"unit": "nyc --reporter=lcovonly --reporter=text --exclude-after-remap=false ava",
"test": "npm run lint && npm run unit"
"release:dry": "standard-version --dry-run",
"test": "npm run lint && npm run unit",
"unit": "nyc --reporter=lcovonly --reporter=text --exclude-after-remap=false ava"
},
"dependencies": {
"@prismicio/types": "^0.1.6",
"@prismicio/types": "^0.1.25",
"change-case": "^4.1.2",

@@ -68,17 +68,17 @@ "faker": "^5.5.3"

"devDependencies": {
"@types/faker": "^5.5.7",
"@typescript-eslint/eslint-plugin": "^4.29.1",
"@typescript-eslint/parser": "^4.29.1",
"@types/faker": "^5.5.8",
"@typescript-eslint/eslint-plugin": "^5.12.0",
"@typescript-eslint/parser": "^5.12.0",
"ava": "^3.15.0",
"eslint": "^7.32.0",
"eslint": "^8.9.0",
"eslint-config-prettier": "^8.3.0",
"eslint-plugin-prettier": "^3.4.0",
"eslint-plugin-prettier": "^4.0.0",
"eslint-plugin-tsdoc": "^0.2.14",
"nyc": "^15.1.0",
"prettier": "^2.3.2",
"prettier-plugin-jsdoc": "^0.3.23",
"siroc": "^0.15.0",
"standard-version": "^9.3.1",
"prettier": "^2.5.1",
"prettier-plugin-jsdoc": "^0.3.30",
"siroc": "^0.16.0",
"standard-version": "^9.3.2",
"ts-eager": "^2.0.2",
"typescript": "^4.3.5"
"typescript": "^4.5.5"
},

@@ -85,0 +85,0 @@ "engines": {

5

README.md

@@ -39,4 +39,6 @@ # @prismicio/mock

**Submitting code changes**: For small fixes, feel free to [open a PR][repo-pull-requests] with a description of your changes. For large changes, please first [open an issue][repo-feature-request] so we can discuss if and how the changes should be implemented.
**Submitting code changes**: For small fixes, feel free to [open a pull request][repo-pull-requests] with a description of your changes. For large changes, please first [open an issue][repo-feature-request] so we can discuss if and how the changes should be implemented.
For more clarity on this project and its structure you can also check out the detailed [CONTRIBUTING.md][contributing] document.
## License

@@ -68,2 +70,3 @@

[changelog]: /CHANGELOG.md
[contributing]: ./CONTRIBUTING.md

@@ -70,0 +73,0 @@ <!-- TODO: Replace link with a more useful one if available -->

7

src/lib/buildContentRelationshipField.ts

@@ -11,3 +11,8 @@ import * as prismicT from "@prismicio/types";

config: BuildEmbedFieldConfig<Document>,
): prismicT.FilledLinkToDocumentField<Document["type"], Document["lang"]> => {
): prismicT.RelationField<
Document["type"],
Document["lang"],
never,
"filled"
> => {
return {

@@ -14,0 +19,0 @@ link_type: prismicT.LinkType.Document,

2

src/lib/buildEmbedField.ts

@@ -14,3 +14,3 @@ import * as prismicT from "@prismicio/types";

config: BuildEmbedFieldConfig,
): prismicT.EmbedField => {
): prismicT.EmbedField<false> => {
const faker = createFaker(config.seed);

@@ -17,0 +17,0 @@

35

src/model/contentRelationship.ts

@@ -5,14 +5,19 @@ import * as prismicT from "@prismicio/types";

import { createFaker } from "../lib/createFaker";
import { generateCustomTypeId } from "../lib/generateCustomTypeId";
import { MockModelConfig } from "../types";
export type MockContentRelationshipModelConfig = {
constrainCustomTypes?: boolean;
constrainTags?: boolean;
export type MockContentRelationshipModelConfig<
CustomTypeIDs extends string = string,
Tags extends string = string,
> = {
customTypeIDs?: readonly CustomTypeIDs[];
tags?: readonly Tags[];
} & MockModelConfig;
export const contentRelationship = (
config: MockContentRelationshipModelConfig = {},
): prismicT.CustomTypeModelContentRelationshipField => {
export const contentRelationship = <
CustomTypeIDs extends string,
Tags extends string,
>(
config: MockContentRelationshipModelConfig<CustomTypeIDs, Tags> = {},
): prismicT.CustomTypeModelContentRelationshipField<CustomTypeIDs, Tags> => {
const faker = createFaker(config.seed);

@@ -26,18 +31,6 @@

select: prismicT.CustomTypeModelLinkSelectType.Document,
customtypes: config.constrainCustomTypes
? Array(faker.datatype.number({ min: 1, max: 3 }))
.fill(undefined)
.map(() => generateCustomTypeId({ seed: config.seed }))
: undefined,
tags: config.constrainTags
? Array(faker.datatype.number({ min: 1, max: 3 }))
.fill(undefined)
.map(() =>
changeCase.capitalCase(
faker.lorem.words(faker.datatype.number({ min: 1, max: 3 })),
),
)
: undefined,
customtypes: config.customTypeIDs,
tags: config.tags,
},
};
};

97

src/model/customType.ts
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;
}

@@ -32,44 +31,46 @@ ) &

export const customType = (
config: MockCustomTypeModelConfig = {},
): prismicT.CustomTypeModel => {
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;
export const customType = <
Definition extends
| prismicT.CustomTypeModelTab
| prismicT.CustomTypeModelDefinition,
>(
config: MockCustomTypeModelConfig<Definition> = {},
): MockCustomTypeModel<Definition> => {
const faker = createFaker(config.seed);
const tabsCount =
config.tabsCount ?? faker.datatype.number({ min: 1, max: 3 });
let label: string =
config.label || changeCase.capitalCase(faker.company.bsNoun());
let id: string = config.id || changeCase.snakeCase(label);
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,
});
if (config.id && !config.label) {
label = changeCase.capitalCase(config.id);
} else if (config.label && !config.label) {
id = changeCase.snakeCase(config.label);
}
if (i === 0 && config.withUID) {
const fieldId = generateFieldId({ seed: config.seed });
let json = {} as MockCustomTypeModel<Definition>["json"];
tabFields[fieldId] = uid();
}
if (config.withSliceZones) {
const sliceZoneId = generateFieldId({ seed: config.seed });
tabFields[sliceZoneId] = sliceZone({
withSharedSlices: config.withSharedSlices,
});
}
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>;
};

23

src/model/group.ts
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 {

@@ -28,5 +21,5 @@ type: prismicT.CustomTypeModelFieldType.Group,

label: changeCase.capitalCase(faker.company.bsNoun()),
fields,
fields: config.fields || ({} as Fields),
},
};
};

26

src/model/image.ts

@@ -8,13 +8,19 @@ import * as prismicT from "@prismicio/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 }),
};
});

@@ -33,11 +39,5 @@ return {

},
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,
},
};
};

2

src/model/index.ts

@@ -25,1 +25,3 @@ export { boolean } from "./boolean";

export { uid } from "./uid";
export { buildMockGroupFieldMap } from "./buildMockGroupFieldMap";

27

src/model/select.ts

@@ -8,18 +8,15 @@ import * as prismicT from "@prismicio/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 {

@@ -30,8 +27,6 @@ type: prismicT.CustomTypeModelFieldType.Select,

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,
},
};
};

55

src/model/sharedSlice.ts

@@ -8,24 +8,9 @@ import * as prismicT from "@prismicio/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;

@@ -39,22 +24,10 @@ export const sharedSlice = <

const name = changeCase.capitalCase(faker.company.bsNoun());
let name: string =
config.name || changeCase.capitalCase(faker.company.bsNoun());
let id: string = config.id || changeCase.snakeCase(name);
let variations: Variation[] = [];
if ("variations" in config) {
variations = config.variations || [];
} else {
const variationsCount =
config.variationsCount ?? faker.datatype.number({ min: 1, max: 3 });
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);
}

@@ -64,7 +37,7 @@

type: prismicT.CustomTypeModelSliceType.SharedSlice,
id: changeCase.snakeCase(name),
id,
name,
description: faker.lorem.sentence(),
variations,
variations: config.variations || ([] as Variation[]),
};
};

54

src/model/sharedSliceVariation.ts

@@ -5,23 +5,41 @@ import * as prismicT from "@prismicio/types";

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,

@@ -31,11 +49,5 @@ description: faker.lorem.sentence(),

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),
};
};

34

src/model/slice.ts

@@ -5,17 +5,19 @@ import * as prismicT from "@prismicio/types";

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);

@@ -31,11 +33,5 @@

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),
};
};

82

src/model/sliceZone.ts
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<
Slices extends Record<
string,
prismicT.CustomTypeModelSlice | prismicT.CustomTypeModelSharedSlice
> = Record<
string,
prismicT.CustomTypeModelSlice | prismicT.CustomTypeModelSharedSlice
>,
> = {
choices?: Slices;
} & MockModelConfig;
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<
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"];
if ("choices" in config) {
choices = config.choices || {};
} else {
const choicesCount =
config.choicesCount ?? faker.datatype.number({ min: 2, max: 6 });
for (const choiceId in config.choices) {
const choice = config.choices[choiceId];
for (let i = 0; i < choicesCount; i++) {
const choiceId = generateFieldId({ seed: config.seed });
choices[choiceId] = config.withSharedSlices
? sharedSliceChoice()
: slice({ seed: config.seed });
}
}
const labels: Record<string, prismicT.CustomTypeModelSliceLabel[]> = {};
for (const choiceId in choices) {
const choice = 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] = [];
}

@@ -77,5 +41,5 @@ }

labels,
choices,
choices: config.choices || ({} as Slices),
},
};
};

53

src/types.ts

@@ -13,6 +13,4 @@ import * as prismicT from "@prismicio/types";

export type ValueOf<
ObjectType,
ValueType extends keyof ObjectType = keyof ObjectType,
> = ObjectType[ValueType];
export type ValueOf<ObjectType extends Record<string, unknown>> =
ObjectType[string];

@@ -64,2 +62,7 @@ type Simplify<T> = { [KeyType in keyof T]: T[KeyType] };

export type GroupFieldModelMap = Record<
string,
prismicT.CustomTypeModelFieldForGroup
>;
export type MockValueConfig<Model extends PrismicModel = PrismicModel> = {

@@ -70,2 +73,8 @@ seed?: Seed;

export type MockValueStateConfig<
State extends prismicT.FieldState = prismicT.FieldState,
> = {
state?: State;
};
export type MockValueConfigForModel<Model extends PrismicModel> =

@@ -133,3 +142,13 @@ Model extends prismicT.CustomTypeModelBooleanField

: 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

@@ -147,3 +166,11 @@ ? CustomTypeModelSliceValue<T>

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];
}>
>;

@@ -190,8 +217,10 @@ type CustomTypeModelFieldForGroupValue<

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"]>
>;

@@ -198,0 +227,0 @@ type SharedSliceModelValue<T extends prismicT.SharedSliceModel> =

22

src/value/color.ts

@@ -5,14 +5,24 @@ import * as prismicT from "@prismicio/types";

import { MockValueConfig } from "../types";
import { MockValueStateConfig, MockValueConfig } from "../types";
export type MockColorValueConfig<
Model extends prismicT.CustomTypeModelColorField = prismicT.CustomTypeModelColorField,
> = MockValueConfig<Model>;
State extends prismicT.FieldState = prismicT.FieldState,
> = MockValueConfig<Model> & MockValueStateConfig<State>;
export const color = (
config: MockColorValueConfig = {},
): prismicT.ColorField => {
export type MockColorValue<
State extends prismicT.FieldState = prismicT.FieldState,
> = prismicT.ColorField<State>;
export const color = <
Model extends prismicT.CustomTypeModelColorField = prismicT.CustomTypeModelColorField,
State extends prismicT.FieldState = "filled",
>(
config: MockColorValueConfig<Model, State> = {},
): MockColorValue<State> => {
const faker = createFaker(config.seed);
return faker.internet.color().toUpperCase() as prismicT.ColorField;
return (
config.state === "empty" ? null : faker.internet.color().toUpperCase()
) as MockColorValue<State>;
};

81

src/value/contentRelationship.ts

@@ -8,3 +8,3 @@ import * as prismicT from "@prismicio/types";

import { MockValueConfig } from "../types";
import { MockValueStateConfig, MockValueConfig } from "../types";

@@ -16,6 +16,5 @@ import * as modelGen from "../model";

export type MockContentRelationshipValueConfig<
IsFilled extends boolean = boolean,
Model extends prismicT.CustomTypeModelContentRelationshipField = prismicT.CustomTypeModelContentRelationshipField,
State extends prismicT.FieldState = prismicT.FieldState,
> = {
isFilled?: IsFilled;
/**

@@ -25,20 +24,28 @@ * A list of potential documents to which the field can be linked.

linkableDocuments?: prismicT.PrismicDocument[];
} & MockValueConfig<Model>;
} & MockValueConfig<Model> &
MockValueStateConfig<State>;
type MockContentRelationshipValue<IsFilled extends boolean = boolean> =
IsFilled extends true
? prismicT.FilledLinkToDocumentField
: prismicT.EmptyLinkField<prismicT.LinkType.Document>;
type MockContentRelationshipValue<
Model extends prismicT.CustomTypeModelContentRelationshipField = prismicT.CustomTypeModelContentRelationshipField,
State extends prismicT.FieldState = prismicT.FieldState,
> = prismicT.RelationField<
Model["config"]["customtypes"],
string,
never,
State
>;
export const contentRelationship = <
IsFilled extends boolean = true,
Model extends prismicT.CustomTypeModelContentRelationshipField = prismicT.CustomTypeModelContentRelationshipField,
State extends prismicT.FieldState = "filled",
>(
config: MockContentRelationshipValueConfig<IsFilled, Model> = {},
): MockContentRelationshipValue<IsFilled> => {
config: MockContentRelationshipValueConfig<Model, State> = {},
): MockContentRelationshipValue<Model, State> => {
const faker = createFaker(config.seed);
const isFilled = config.isFilled ?? true;
if (isFilled) {
if (config.state === "empty") {
return {
link_type: prismicT.LinkType.Document,
} as MockContentRelationshipValue<Model, State>;
} else {
const model =

@@ -48,18 +55,25 @@ config.model || modelGen.contentRelationship({ seed: config.seed });

const linkableDocuments = config.linkableDocuments
? config.linkableDocuments.filter((document) => {
let shouldKeep = true;
? config.linkableDocuments.filter(
(
document,
): document is prismicT.PrismicDocument<
never,
NonNullable<Model["config"]["customtypes"]>[number]
> => {
let shouldKeep = true;
if (model.config.customtypes) {
shouldKeep =
shouldKeep && model.config.customtypes.includes(document.type);
}
if (model.config.customtypes) {
shouldKeep =
shouldKeep && model.config.customtypes.includes(document.type);
}
if (model.config.tags) {
shouldKeep =
shouldKeep &&
model.config.tags.some((tag) => document.tags.includes(tag));
}
if (model.config.tags) {
shouldKeep =
shouldKeep &&
model.config.tags.some((tag) => document.tags.includes(tag));
}
return shouldKeep;
})
return shouldKeep;
},
)
: [

@@ -74,3 +88,6 @@ {

: generateTags({ seed: config.seed }),
},
} as prismicT.PrismicDocument<
never,
NonNullable<Model["config"]["customtypes"]>[number]
>,
];

@@ -84,8 +101,6 @@

return buildContentRelationshipField({ document });
} else {
return {
link_type: prismicT.LinkType.Document,
} as MockContentRelationshipValue<IsFilled>;
return buildContentRelationshipField({
document,
}) as unknown as MockContentRelationshipValue<Model, State>;
}
};

34

src/value/date.ts
import * as prismicT from "@prismicio/types";
import { MockValueConfig } from "../types";
import { MockValueStateConfig, MockValueConfig } from "../types";

@@ -9,11 +9,27 @@ import { MockTimestampValueConfig, timestamp } from "./timestamp";

Model extends prismicT.CustomTypeModelDateField = prismicT.CustomTypeModelDateField,
> = Pick<MockTimestampValueConfig, "after" | "before"> & MockValueConfig<Model>;
State extends prismicT.FieldState = prismicT.FieldState,
> = Pick<MockTimestampValueConfig, "after" | "before"> &
MockValueConfig<Model> &
MockValueStateConfig<State>;
export const date = (config: MockDateValueConfig = {}): prismicT.DateField => {
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
return timestamp({
seed: config.seed,
after: config.after,
before: config.before,
})!.split("T")[0];
export type MockDateValue<
State extends prismicT.FieldState = prismicT.FieldState,
> = prismicT.DateField<State>;
export const date = <
Model extends prismicT.CustomTypeModelDateField = prismicT.CustomTypeModelDateField,
State extends prismicT.FieldState = "filled",
>(
config: MockDateValueConfig<Model, State> = {},
): MockDateValue<State> => {
return (
config.state === "empty"
? null
: timestamp({
seed: config.seed,
after: config.after,
before: config.before,
state: "filled",
}).split("T")[0]
) as MockDateValue<State>;
};

24

src/value/embed.ts

@@ -6,14 +6,26 @@ import * as prismicT from "@prismicio/types";

import { MockValueConfig } from "../types";
import { MockValueStateConfig, MockValueConfig } from "../types";
export type MockEmbedValueConfig<
Model extends prismicT.CustomTypeModelEmbedField = prismicT.CustomTypeModelEmbedField,
> = MockValueConfig<Model>;
State extends prismicT.FieldState = prismicT.FieldState,
> = MockValueConfig<Model> & MockValueStateConfig<State>;
export const embed = (
config: MockEmbedValueConfig = {},
): prismicT.EmbedField => {
export type MockEmbedValue<
State extends prismicT.FieldState = prismicT.FieldState,
> = prismicT.EmbedField<prismicT.AnyOEmbed & prismicT.OEmbedExtra, State>;
export const embed = <
Model extends prismicT.CustomTypeModelEmbedField = prismicT.CustomTypeModelEmbedField,
State extends prismicT.FieldState = "filled",
>(
config: MockEmbedValueConfig<Model, State> = {},
): MockEmbedValue<State> => {
const embedData = getMockEmbedData({ seed: config.seed });
return buildEmbedField({ seed: config.seed, embedData });
return (
config.state === "empty"
? {}
: buildEmbedField({ seed: config.seed, embedData })
) as MockEmbedValue<State>;
};

30

src/value/geoPoint.ts

@@ -5,11 +5,19 @@ import * as prismicT from "@prismicio/types";

import { MockValueConfig } from "../types";
import { MockValueStateConfig, MockValueConfig } from "../types";
export type MockGeoPointValueConfig<
Model extends prismicT.CustomTypeModelGeoPointField = prismicT.CustomTypeModelGeoPointField,
> = MockValueConfig<Model>;
State extends prismicT.FieldState = prismicT.FieldState,
> = MockValueConfig<Model> & MockValueStateConfig<State>;
export const geoPoint = (
config: MockGeoPointValueConfig = {},
): prismicT.GeoPointField => {
export type MockGeoPointValue<
State extends prismicT.FieldState = prismicT.FieldState,
> = prismicT.GeoPointField<State>;
export const geoPoint = <
Model extends prismicT.CustomTypeModelGeoPointField = prismicT.CustomTypeModelGeoPointField,
State extends prismicT.FieldState = "filled",
>(
config: MockGeoPointValueConfig<Model, State> = {},
): MockGeoPointValue<State> => {
const faker = createFaker(config.seed);

@@ -19,6 +27,10 @@

return {
longitude: Number.parseFloat(coordinates[0]),
latitude: Number.parseFloat(coordinates[1]),
};
return (
config.state === "empty"
? {}
: {
longitude: Number.parseFloat(coordinates[0]),
latitude: Number.parseFloat(coordinates[1]),
}
) as MockGeoPointValue<State>;
};

34

src/value/group.ts

@@ -13,21 +13,6 @@ import * as prismicT from "@prismicio/types";

const patterns = {
short: {
minItems: 1,
maxItems: 3,
},
medium: {
minItems: 3,
maxItems: 6,
},
long: {
minItems: 6,
maxItems: 12,
},
} as const;
export type MockGroupValueConfig<
Model extends prismicT.CustomTypeModelGroupField = prismicT.CustomTypeModelGroupField,
> = {
pattern?: keyof typeof patterns;
itemsCount?: number;
configs?: ValueForModelMapConfigs;

@@ -45,14 +30,9 @@ } & MockValueConfig<Model>;

const patternKey =
config.pattern ||
faker.random.arrayElement(
Object.keys(patterns) as (keyof typeof patterns)[],
);
const pattern = patterns[patternKey];
const itemsCount =
config.itemsCount ??
faker.datatype.number({
min: 1,
max: 6,
});
const itemsCount = faker.datatype.number({
min: pattern.minItems,
max: pattern.maxItems,
});
return Array(itemsCount)

@@ -59,0 +39,0 @@ .fill(undefined)

31

src/value/image.ts
import * as prismicT from "@prismicio/types";
import { buildImageField } from "../lib/buildImageField";
import { buildImageFieldImage } from "../lib/buildImageFieldImage";
import { getMockImageData } from "../lib/getMockImageData";
import { MockValueConfig } from "../types";
import { MockValueStateConfig, MockValueConfig } from "../types";

@@ -12,18 +12,30 @@ import * as modelGen from "../model";

Model extends prismicT.CustomTypeModelImageField = prismicT.CustomTypeModelImageField,
> = MockValueConfig<Model>;
State extends prismicT.FieldState = prismicT.FieldState,
> = MockValueConfig<Model> & MockValueStateConfig<State>;
export const image = (
config: MockImageValueConfig = {},
): prismicT.ImageField => {
export type MockImageValue<
Model extends prismicT.CustomTypeModelImageField = prismicT.CustomTypeModelImageField,
State extends prismicT.FieldState = prismicT.FieldState,
> = prismicT.ImageField<Model["config"]["thumbnails"][number]["name"], State>;
export const image = <
Model extends prismicT.CustomTypeModelImageField = prismicT.CustomTypeModelImageField,
State extends prismicT.FieldState = "filled",
>(
config: MockImageValueConfig<Model, State> = {},
): MockImageValue<Model, State> => {
const model = config.model || modelGen.image({ seed: config.seed });
const imageData = getMockImageData({ seed: config.seed });
const value = buildImageField({
const value = buildImageFieldImage({
seed: config.seed,
imageData,
constraint: model.config.constraint,
});
state: config.state,
}) as MockImageValue<Model, State>;
for (const thumbnail of model.config.thumbnails) {
value[thumbnail.name] = buildImageField({
// TODO: Resolve the following type error
// @ts-expect-error - Unsure how to fix this type mismatch
value[thumbnail.name as keyof typeof value] = buildImageFieldImage({
seed: config.seed,

@@ -35,2 +47,3 @@ imageData,

},
state: config.state,
});

@@ -37,0 +50,0 @@ }

40

src/value/integrationFields.ts

@@ -7,17 +7,25 @@ import * as prismicT from "@prismicio/types";

import { MockValueConfig } from "../types";
import { MockValueStateConfig, MockValueConfig } from "../types";
export type MockIntegrationFieldsValueConfig<
Model extends prismicT.CustomTypeModelIntegrationFieldsField = prismicT.CustomTypeModelIntegrationFieldsField,
Blob extends unknown = unknown,
Blob = unknown,
State extends prismicT.FieldState = prismicT.FieldState,
> = {
data?: Blob;
} & MockValueConfig<Model>;
} & MockValueConfig<Model> &
MockValueStateConfig<State>;
export type MockIntegrationFieldsValue<
Blob = unknown,
State extends prismicT.FieldState = prismicT.FieldState,
> = prismicT.IntegrationFields<Blob, State>;
export const integrationFields = <
Model extends prismicT.CustomTypeModelIntegrationFieldsField = prismicT.CustomTypeModelIntegrationFieldsField,
Blob extends unknown = unknown,
Blob = unknown,
State extends prismicT.FieldState = "filled",
>(
config: MockIntegrationFieldsValueConfig<Model, Blob> = {},
): prismicT.IntegrationFields<Blob> => {
config: MockIntegrationFieldsValueConfig<Model, Blob, State> = {},
): MockIntegrationFieldsValue<Blob, State> => {
const faker = createFaker(config.seed);

@@ -27,10 +35,14 @@

return {
id: faker.git.shortSha(),
title: changeCase.capitalCase(faker.lorem.words(3)),
description: faker.lorem.sentence(),
image_url: imageData.url,
last_update: faker.date.past(20, new Date("2021-03-07")).getTime(),
blob: config.data as Blob,
};
return (
config.state === "empty"
? null
: {
id: faker.git.shortSha(),
title: changeCase.capitalCase(faker.lorem.words(3)),
description: faker.lorem.sentence(),
image_url: imageData.url,
last_update: faker.date.past(20, new Date("2021-03-07")).getTime(),
blob: config.data as Blob,
}
) as MockIntegrationFieldsValue<Blob, State>;
};

24

src/value/keyText.ts

@@ -6,14 +6,26 @@ import * as prismicT from "@prismicio/types";

import { MockValueConfig } from "../types";
import { MockValueStateConfig, MockValueConfig } from "../types";
export type MockKeyTextValueConfig<
Model extends prismicT.CustomTypeModelKeyTextField = prismicT.CustomTypeModelKeyTextField,
> = MockValueConfig<Model>;
State extends prismicT.FieldState = prismicT.FieldState,
> = MockValueConfig<Model> & MockValueStateConfig<State>;
export const keyText = (
config: MockKeyTextValueConfig = {},
): prismicT.KeyTextField => {
export type MockKeyTextValue<
State extends prismicT.FieldState = prismicT.FieldState,
> = prismicT.KeyTextField<State>;
export const keyText = <
Model extends prismicT.CustomTypeModelKeyTextField = prismicT.CustomTypeModelKeyTextField,
State extends prismicT.FieldState = "filled",
>(
config: MockKeyTextValueConfig<Model, State> = {},
): MockKeyTextValue<State> => {
const faker = createFaker(config.seed);
return changeCase.sentenceCase(faker.lorem.words(3));
return (
config.state === "empty"
? null
: changeCase.sentenceCase(faker.lorem.words(3))
) as MockKeyTextValue<State>;
};

67

src/value/link.ts

@@ -5,3 +5,3 @@ import * as prismicT from "@prismicio/types";

import { MockValueConfig } from "../types";
import { MockValueStateConfig, MockValueConfig } from "../types";

@@ -14,8 +14,7 @@ import * as modelGen from "../model";

export type MockLinkValueConfig<
LinkType extends prismicT.LinkType = prismicT.LinkType,
IsFilled extends boolean = true,
LinkType extends typeof prismicT.LinkType[keyof typeof prismicT.LinkType] = typeof prismicT.LinkType[keyof typeof prismicT.LinkType],
Model extends prismicT.CustomTypeModelLinkField = prismicT.CustomTypeModelLinkField,
State extends prismicT.FieldState = prismicT.FieldState,
> = {
type?: LinkType;
isFilled?: IsFilled;
withTargetBlank?: Model["config"]["allowTargetBlank"] extends undefined

@@ -27,31 +26,30 @@ ? false

*/
linkableDocuments?: LinkType extends prismicT.LinkType.Document
linkableDocuments?: LinkType extends typeof prismicT.LinkType.Document
? prismicT.PrismicDocument[]
: never;
} & MockValueConfig<Model>;
} & MockValueConfig<Model> &
MockValueStateConfig<State>;
type MockLinkValue<
LinkType extends prismicT.LinkType = prismicT.LinkType,
IsFilled extends boolean = true,
> = IsFilled extends true
? LinkType extends prismicT.LinkType.Web
? prismicT.FilledLinkToWebField
: LinkType extends prismicT.LinkType.Media
? prismicT.FilledLinkToMediaField
: LinkType extends prismicT.LinkType.Document
? prismicT.FilledLinkToDocumentField
: never
: prismicT.EmptyLinkField<LinkType>;
LinkType extends typeof prismicT.LinkType[keyof typeof prismicT.LinkType] = typeof prismicT.LinkType[keyof typeof prismicT.LinkType],
State extends prismicT.FieldState = "filled",
> = State extends "empty"
? prismicT.EmptyLinkField<LinkType>
: LinkType extends typeof prismicT.LinkType.Web
? prismicT.FilledLinkToWebField
: LinkType extends typeof prismicT.LinkType.Media
? prismicT.FilledLinkToMediaField
: LinkType extends typeof prismicT.LinkType.Document
? prismicT.FilledLinkToDocumentField
: never;
export const link = <
LinkType extends prismicT.LinkType = prismicT.LinkType,
IsFilled extends boolean = true,
LinkType extends typeof prismicT.LinkType[keyof typeof prismicT.LinkType] = typeof prismicT.LinkType[keyof typeof prismicT.LinkType],
Model extends prismicT.CustomTypeModelLinkField = prismicT.CustomTypeModelLinkField,
State extends prismicT.FieldState = "filled",
>(
config: MockLinkValueConfig<LinkType, IsFilled, Model> = {},
): MockLinkValue<LinkType, IsFilled> => {
config: MockLinkValueConfig<LinkType, Model, State> = {},
): MockLinkValue<LinkType, State> => {
const faker = createFaker(config.seed);
const isFilled = config.isFilled ?? true;
const type =

@@ -65,3 +63,7 @@ config.type ||

if (isFilled) {
if (config.state === "empty") {
return {
link_type: type,
} as MockLinkValue<LinkType, State>;
} else {
switch (type) {

@@ -71,5 +73,5 @@ case prismicT.LinkType.Document: {

seed: config.seed,
isFilled,
state: config.state,
linkableDocuments: config.linkableDocuments,
}) as MockLinkValue<LinkType, IsFilled>;
}) as unknown as MockLinkValue<LinkType, State>;
}

@@ -80,7 +82,8 @@

seed: config.seed,
isFilled,
}) as MockLinkValue<LinkType, IsFilled>;
state: config.state,
}) as MockLinkValue<LinkType, State>;
}
case prismicT.LinkType.Web: {
case prismicT.LinkType.Web:
default: {
const model = config.model || modelGen.link({ seed: config.seed });

@@ -96,10 +99,6 @@

: undefined,
} as MockLinkValue<LinkType, IsFilled>;
} as MockLinkValue<LinkType, State>;
}
}
}
return {
link_type: type,
} as MockLinkValue<LinkType, IsFilled>;
};

35

src/value/linkToMedia.ts

@@ -5,29 +5,28 @@ import * as prismicT from "@prismicio/types";

import { MockValueConfig } from "../types";
import { MockValueStateConfig, MockValueConfig } from "../types";
export type MockLinkToMediaValueConfig<
IsFilled extends boolean = true,
Model extends prismicT.CustomTypeModelLinkToMediaField = prismicT.CustomTypeModelLinkToMediaField,
> = {
isFilled?: IsFilled;
} & MockValueConfig<Model>;
State extends prismicT.FieldState = prismicT.FieldState,
> = MockValueConfig<Model> & MockValueStateConfig<State>;
type MockLinkToMediaValue<IsFilled extends boolean = true> =
IsFilled extends true
? prismicT.FilledLinkToMediaField
: prismicT.EmptyLinkField<prismicT.LinkType.Media>;
type MockLinkToMediaValue<
State extends prismicT.FieldState = prismicT.FieldState,
> = prismicT.LinkToMediaField<State>;
export const linkToMedia = <
IsFilled extends boolean = true,
Model extends prismicT.CustomTypeModelLinkToMediaField = prismicT.CustomTypeModelLinkToMediaField,
State extends prismicT.FieldState = "filled",
>(
config: MockLinkToMediaValueConfig<IsFilled, Model> = {},
): MockLinkToMediaValue<IsFilled> => {
config: MockLinkToMediaValueConfig<Model, State> = {},
): MockLinkToMediaValue<State> => {
const faker = createFaker(config.seed);
const isFilled = config.isFilled ?? true;
if (isFilled) {
if (config.state === "empty") {
return {
link_type: prismicT.LinkType.Media,
} as MockLinkToMediaValue<State>;
} else {
return {
link_type: prismicT.LinkType.Media,
name: faker.system.commonFileName(),

@@ -39,8 +38,4 @@ kind: faker.system.commonFileType(),

width: faker.datatype.number().toString(),
} as prismicT.FilledLinkToMediaField;
} else {
return {
link_type: prismicT.LinkType.Media,
} as MockLinkToMediaValue<IsFilled>;
} as MockLinkToMediaValue<State>;
}
};

22

src/value/number.ts

@@ -5,14 +5,24 @@ import * as prismicT from "@prismicio/types";

import { MockValueConfig } from "../types";
import { MockValueStateConfig, MockValueConfig } from "../types";
export type MockNumberValueConfig<
Model extends prismicT.CustomTypeModelNumberField = prismicT.CustomTypeModelNumberField,
> = MockValueConfig<Model>;
State extends prismicT.FieldState = prismicT.FieldState,
> = MockValueConfig<Model> & MockValueStateConfig<State>;
export const number = (
config: MockNumberValueConfig = {},
): prismicT.NumberField => {
export type MockNumberValue<
State extends prismicT.FieldState = prismicT.FieldState,
> = prismicT.NumberField<State>;
export const number = <
Model extends prismicT.CustomTypeModelNumberField = prismicT.CustomTypeModelNumberField,
State extends prismicT.FieldState = "filled",
>(
config: MockNumberValueConfig<Model, State> = {},
): MockNumberValue<State> => {
const faker = createFaker(config.seed);
return faker.datatype.number();
return (
config.state === "empty" ? null : faker.datatype.number()
) as MockNumberValue<State>;
};

14

src/value/richText/heading.ts

@@ -11,8 +11,8 @@ import * as prismicT from "@prismicio/types";

type RichTextNodeTitleType =
| prismicT.RichTextNodeType.heading1
| prismicT.RichTextNodeType.heading2
| prismicT.RichTextNodeType.heading3
| prismicT.RichTextNodeType.heading4
| prismicT.RichTextNodeType.heading5
| prismicT.RichTextNodeType.heading6;
| typeof prismicT.RichTextNodeType.heading1
| typeof prismicT.RichTextNodeType.heading2
| typeof prismicT.RichTextNodeType.heading3
| typeof prismicT.RichTextNodeType.heading4
| typeof prismicT.RichTextNodeType.heading5
| typeof prismicT.RichTextNodeType.heading6;

@@ -65,3 +65,3 @@ type RTHeadingNode =

prismicT.RichTextNodeType.heading6,
].includes(type as prismicT.RichTextNodeType),
].includes(type as RichTextNodeTitleType),
) as RichTextNodeTitleType[];

@@ -68,0 +68,0 @@ const type = faker.random.arrayElement(types);

8

src/value/richText/image.ts
import * as prismicT from "@prismicio/types";
import { buildImageField } from "../../lib/buildImageField";
import { buildImageFieldImage } from "../../lib/buildImageFieldImage";
import { getMockImageData } from "../../lib/getMockImageData";

@@ -14,3 +14,7 @@

const imageData = getMockImageData({ seed: config.seed });
const imageField = buildImageField({ seed: config.seed, imageData });
const imageField = buildImageFieldImage({
seed: config.seed,
imageData,
state: false,
});

@@ -17,0 +21,0 @@ return {

2

src/value/richText/index.ts

@@ -95,3 +95,3 @@ import * as prismicT from "@prismicio/types";

.filter((block): block is prismicT.RTNode => block !== undefined)
.slice(0, blockCount);
.slice(0, blockCount) as prismicT.RichTextField;
} else {

@@ -98,0 +98,0 @@ return [];

31

src/value/select.ts

@@ -5,3 +5,3 @@ import * as prismicT from "@prismicio/types";

import { MockValueConfig } from "../types";
import { MockValueStateConfig, MockValueConfig } from "../types";

@@ -12,7 +12,16 @@ import * as modelGen from "../model";

Model extends prismicT.CustomTypeModelSelectField = prismicT.CustomTypeModelSelectField,
> = MockValueConfig<Model>;
State extends prismicT.FieldState = prismicT.FieldState,
> = MockValueConfig<Model> & MockValueStateConfig<State>;
export const select = (
config: MockSelectValueConfig = {},
): prismicT.SelectField => {
export type MockSelectValue<
Model extends prismicT.CustomTypeModelSelectField = prismicT.CustomTypeModelSelectField,
State extends prismicT.FieldState = prismicT.FieldState,
> = prismicT.SelectField<Model["config"]["options"][number], State>;
export const select = <
Model extends prismicT.CustomTypeModelSelectField = prismicT.CustomTypeModelSelectField,
State extends prismicT.FieldState = "filled",
>(
config: MockSelectValueConfig<Model, State> = {},
): MockSelectValue<Model, State> => {
const faker = createFaker(config.seed);

@@ -23,5 +32,11 @@

return typeof defaultValue === "string" && faker.datatype.boolean()
? defaultValue
: faker.random.arrayElement(model.config.options);
if (config.state === "empty") {
return null as MockSelectValue<Model, State>;
} else {
return (
typeof defaultValue === "string" && faker.datatype.boolean()
? defaultValue
: faker.random.arrayElement(model.config.options)
) as MockSelectValue<Model, State>;
}
};

4

src/value/sharedSlice.ts

@@ -17,3 +17,3 @@ import * as prismicT from "@prismicio/types";

MockSharedSliceVariationValueConfig,
"pattern" | "primaryFieldConfigs" | "itemsFieldConfigs"
"itemsCount" | "primaryFieldConfigs" | "itemsFieldConfigs"
> &

@@ -35,3 +35,3 @@ MockValueConfig<Model>;

model: variationModel,
pattern: config.pattern,
itemsCount: config.itemsCount,
type: model.id,

@@ -38,0 +38,0 @@ primaryFieldConfigs: config.primaryFieldConfigs,

40

src/value/sharedSliceVariation.ts
import * as prismicT from "@prismicio/types";
import * as changeCase from "change-case";

@@ -15,21 +14,2 @@ import { MockValueConfig, ModelValue } from "../types";

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 MockSharedSliceVariationValueConfig<

@@ -40,3 +20,3 @@ Model extends prismicT.SharedSliceModelVariation = prismicT.SharedSliceModelVariation,

label?: string;
pattern?: keyof typeof patterns;
itemsCount?: number;
primaryFieldConfigs?: ValueForModelMapConfigs;

@@ -56,18 +36,10 @@ itemsFieldConfigs?: ValueForModelMapConfigs;

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 ?? changeCase.capitalCase(faker.company.bsNoun());
const itemsCount =
Object.keys(model.items).length > 0
? faker.datatype.number({
min: pattern.minItems,
max: pattern.maxItems,
? config.itemsCount ??
faker.datatype.number({
min: 1,
max: 6,
})

@@ -78,3 +50,3 @@ : 0;

slice_type: sliceType,
slice_label: sliceLabel,
slice_label: null,
variation: model.id,

@@ -81,0 +53,0 @@ version: faker.git.shortSha(),

35

src/value/slice.ts

@@ -15,21 +15,2 @@ import * as prismicT from "@prismicio/types";

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<

@@ -40,3 +21,3 @@ Model extends prismicT.CustomTypeModelSlice = prismicT.CustomTypeModelSlice,

label?: string | null;
pattern?: keyof typeof patterns;
itemsCount?: number;
primaryFieldConfigs?: ValueForModelMapConfigs;

@@ -55,9 +36,2 @@ itemsFieldConfigs?: ValueForModelMapConfigs;

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 });

@@ -71,5 +45,6 @@ const sliceLabel =

Object.keys(model.repeat).length > 0
? faker.datatype.number({
min: pattern.minItems,
max: pattern.maxItems,
? config.itemsCount ??
faker.datatype.number({
min: 1,
max: 6,
})

@@ -76,0 +51,0 @@ : 0;

104

src/value/sliceZone.ts

@@ -13,17 +13,2 @@ import * as prismicT from "@prismicio/types";

const patterns = {
short: {
minItems: 1,
maxItems: 3,
},
medium: {
minItems: 3,
maxItems: 6,
},
long: {
minItems: 6,
maxItems: 12,
},
} as const;
export type MockSliceZoneValueConfig<

@@ -33,3 +18,3 @@ Model extends prismicT.CustomTypeModelSliceZoneField = prismicT.CustomTypeModelSliceZoneField,

sharedSliceModels?: prismicT.SharedSliceModel[];
pattern?: keyof typeof patterns;
itemsCount?: number;
primaryFieldConfigs?: ValueForModelMapConfigs;

@@ -48,44 +33,26 @@ itemsFieldConfigs?: ValueForModelMapConfigs;

const patternKey =
config.pattern ||
faker.random.arrayElement(
Object.keys(patterns) as (keyof typeof patterns)[],
);
const pattern = patterns[patternKey];
if (Object.keys(model.config.choices).length > 0) {
const itemsCount =
config.itemsCount ??
faker.datatype.number({
min: 1,
max: 6,
});
const itemsCount = faker.datatype.number({
min: pattern.minItems,
max: pattern.maxItems,
});
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,
});
}
case prismicT.CustomTypeModelSliceType.SharedSlice: {
const sharedSliceModel = config.sharedSliceModels?.find(
(sharedSliceModel) => sharedSliceModel.id === choiceType,
);
if (sharedSliceModel) {
return sharedSlice({
switch (choiceModel.type) {
case prismicT.CustomTypeModelSliceType.Slice: {
return slice({
seed: config.seed,
model: sharedSliceModel,
model: choiceModel,
type: choiceType,
label: choiceLabel ? choiceLabel.name : null,
primaryFieldConfigs: config.primaryFieldConfigs,

@@ -95,9 +62,26 @@ itemsFieldConfigs: config.itemsFieldConfigs,

}
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,
});
}
}
}
}
})
.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>;
} else {
return [] as unknown as ModelValue<Model>;
}
};

25

src/value/timestamp.ts

@@ -5,14 +5,23 @@ import * as prismicT from "@prismicio/types";

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);

@@ -30,3 +39,7 @@

return faker.date.between(after, before).toISOString();
return (
config.state === "empty"
? null
: faker.date.between(after, before).toISOString()
) as MockTimestampValue<State>;
};

2

src/value/title.ts

@@ -23,3 +23,3 @@ import * as prismicT from "@prismicio/types";

})!,
];
] as prismicT.TitleField;
};

2

src/value/uid.ts

@@ -14,3 +14,3 @@ import * as prismicT from "@prismicio/types";

config: MockUIDValueConfig = {},
): prismicT.PrismicDocument["uid"] => {
): NonNullable<prismicT.PrismicDocument["uid"]> => {
const faker = createFaker(config.seed);

@@ -17,0 +17,0 @@ 

dist/api/index.mjs
dist/index.mjs
dist/model/index.mjs
dist/value/index.mjs
src/lib/buildImageField.ts
src/lib/buildMockGroupFieldMap.ts
dist/api/index.cjs

Sorry, the diff of this file is not supported yet

dist/index.cjs

Sorry, the diff of this file is not supported yet

dist/model/index.cjs

Sorry, the diff of this file is not supported yet

dist/value/index.cjs

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc