@prismicio/types-internal 3.9.0 → 3.10.0-alpha.0

package/lib/customtypes/widgets/Group.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Group = exports.GroupConfig = exports.NestedGroup = exports.NestedGroupConfig = exports.GroupFieldType = void 0;
+exports.traverseGroup = exports.traverseNestedGroup = exports.Group = exports.GroupConfig = exports.NestedGroup = exports.NestedGroupConfig = exports.GroupFieldType = void 0;
 const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const common_1 = require("../../common");
@@ -31,3 +31,79 @@ exports.NestedGroupConfig = createGroupConfig(NestableWidget_1.NestableWidget);
 exports.NestedGroup = createGroup(NestableWidget_1.NestableWidget);
 exports.GroupConfig = createGroupConfig(t.union([NestableWidget_1.NestableWidget, exports.NestedGroup]));
 exports.Group = createGroup(t.union([NestableWidget_1.NestableWidget, exports.NestedGroup]));
+function traverseNestedGroup(args) {
+    var _a;
+    const { path: prevPath, group, onField } = args;
+    const fields = ((_a = group.config) === null || _a === void 0 ? void 0 : _a.fields) &&
+        Object.entries(group.config.fields).reduce((acc, [key, model]) => {
+            const path = prevPath.concat(key);
+            acc[key] = onField({
+                path,
+                key,
+                field: model,
+            });
+            return acc;
+        }, {});
+    return {
+        ...group,
+        ...(group.config && {
+            config: {
+                ...group.config,
+                ...(fields && { fields }),
+            },
+        }),
+    };
+}
+exports.traverseNestedGroup = traverseNestedGroup;
+function traverseGroup(args) {
+    var _a;
+    const { path: prevPath, group, onField } = args;
+    const fields = ((_a = group.config) === null || _a === void 0 ? void 0 : _a.fields) &&
+        Object.entries(group.config.fields).reduce((acc, [key, prevField]) => {
+            const path = prevPath.concat(key);
+            let field;
+            switch (prevField.type) {
+                case "Group":
+                    field = traverseNestedGroup({
+                        path,
+                        group: prevField,
+                        onField: onField,
+                    });
+                    break;
+                case "Boolean":
+                case "Color":
+                case "Date":
+                case "Embed":
+                case "GeoPoint":
+                case "Image":
+                case "IntegrationFields":
+                case "Link":
+                case "Number":
+                case "Range":
+                case "Select":
+                case "Separator":
+                case "StructuredText":
+                case "Table":
+                case "Text":
+                case "Timestamp":
+                    field = prevField;
+                    break;
+            }
+            acc[key] = onField({
+                path,
+                key,
+                field,
+            });
+            return acc;
+        }, {});
+    return {
+        ...group,
+        ...(group.config && {
+            config: {
+                ...group.config,
+                ...(fields && { fields }),
+            },
+        }),
+    };
+}
+exports.traverseGroup = traverseGroup;

package/lib/customtypes/widgets/slices/CompositeSlice.d.ts

@@ -1,4 +1,6 @@
 import * as t from "io-ts";
+import type { OnFieldFn } from "../../../_internal/utils";
+import { NestableWidget } from "../nestable/NestableWidget";
 import type { DynamicSlice, StaticSlice } from "./Slice";
 export declare const CompositeSliceType = "Slice";
 export declare const CompositeSliceConfig: t.ExactC<t.PartialC<{
@@ -394,3 +396,8 @@ export declare const CompositeSlice: t.ExactC<t.IntersectionC<[t.TypeC<{
 }>]>>;
 export declare type CompositeSlice = t.TypeOf<typeof CompositeSlice>;
 export declare function isCompositeSlice(slice: DynamicSlice | StaticSlice): slice is CompositeSlice;
+export declare function traverseCompositeSlice(args: {
+    path: ReadonlyArray<string>;
+    slice: CompositeSlice;
+    onField: OnFieldFn<NestableWidget>;
+}): CompositeSlice;

package/lib/customtypes/widgets/slices/CompositeSlice.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCompositeSlice = exports.CompositeSlice = exports.CompositeSliceConfig = exports.CompositeSliceType = void 0;
+exports.traverseCompositeSlice = exports.isCompositeSlice = exports.CompositeSlice = exports.CompositeSliceConfig = exports.CompositeSliceType = void 0;
 const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const common_1 = require("../../../common");
@@ -28,3 +28,28 @@ function isCompositeSlice(slice) {
     return slice.type === "Slice";
 }
 exports.isCompositeSlice = isCompositeSlice;
+function traverseCompositeSlice(args) {
+    const { path: prevPath, slice, onField } = args;
+    const nonRepeat = slice["non-repeat"] &&
+        Object.entries(slice["non-repeat"]).reduce((acc, [key, field]) => {
+            const path = prevPath.concat("non-repeat", key);
+            acc[key] = onField({ path, key, field });
+            return acc;
+        }, {});
+    const repeat = slice.repeat &&
+        Object.entries(slice.repeat).reduce((acc, [key, field]) => {
+            const path = prevPath.concat("repeat", key);
+            acc[key] = onField({ path, key, field });
+            return acc;
+        }, {});
+    return {
+        ...slice,
+        ...(nonRepeat && {
+            "non-repeat": nonRepeat,
+        }),
+        ...(repeat && {
+            repeat,
+        }),
+    };
+}
+exports.traverseCompositeSlice = traverseCompositeSlice;

package/lib/customtypes/widgets/slices/SharedSlice.d.ts

@@ -1,4 +1,7 @@
 import * as t from "io-ts";
+import type { OnFieldFn } from "../../../_internal/utils";
+import { Group, NestedGroup } from "../Group";
+import { NestableWidget } from "../nestable/NestableWidget";
 import type { SharedSliceRef } from "./SharedSliceRef";
 import type { DynamicSlice, StaticSlice } from "./Slice";
 export declare const Variation: t.ExactC<t.IntersectionC<[t.TypeC<{
@@ -1584,3 +1587,13 @@ export declare const SharedSlice: t.ExactC<t.IntersectionC<[t.TypeC<{
 export declare type SharedSlice = t.TypeOf<typeof SharedSlice>;
 export declare function isStaticSharedSlice(slice: StaticSlice): slice is SharedSlice;
 export declare function isDynamicSharedSlice(slice: DynamicSlice): slice is SharedSliceRef;
+export declare function traverseVariation(args: {
+    path: ReadonlyArray<string>;
+    variation: Variation;
+    onField: OnFieldFn<NestableWidget | Group | NestedGroup>;
+}): Variation;
+export declare function traverseSharedSlice(args: {
+    path: ReadonlyArray<string>;
+    slice: SharedSlice;
+    onField: OnFieldFn<NestableWidget | Group | NestedGroup>;
+}): SharedSlice;

package/lib/customtypes/widgets/slices/SharedSlice.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDynamicSharedSlice = exports.isStaticSharedSlice = exports.SharedSlice = exports.SharedSliceType = exports.Variation = void 0;
+exports.traverseSharedSlice = exports.traverseVariation = exports.isDynamicSharedSlice = exports.isStaticSharedSlice = exports.SharedSlice = exports.SharedSliceType = exports.Variation = void 0;
 const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const withFallback_1 = require("io-ts-types/lib/withFallback");
 const common_1 = require("../../../common");
+const Group_1 = require("../Group");
 const NestableWidget_1 = require("../nestable/NestableWidget");
 const SlicePrimaryWidget_1 = require("./SlicePrimaryWidget");
 const IMAGE_PLACEHOLDER_URL = "https://images.prismic.io/slice-machine/621a5ec4-0387-4bc5-9860-2dd46cbc07cd_default_ss.png?auto=compress,format";
@@ -46,3 +47,75 @@ function isDynamicSharedSlice(slice) {
     return slice.type === "SharedSlice";
 }
 exports.isDynamicSharedSlice = isDynamicSharedSlice;
+function traverseVariation(args) {
+    const { path: prevPath, variation, onField } = args;
+    return {
+        ...variation,
+        ...(variation.primary && {
+            primary: Object.entries(variation.primary).reduce((acc, [key, prevField]) => {
+                const path = prevPath.concat("primary", key);
+                let field;
+                switch (prevField.type) {
+                    case "Group":
+                        field = (0, Group_1.traverseGroup)({
+                            path,
+                            group: prevField,
+                            onField: onField,
+                        });
+                        break;
+                    case "Boolean":
+                    case "Color":
+                    case "Date":
+                    case "Embed":
+                    case "GeoPoint":
+                    case "Image":
+                    case "IntegrationFields":
+                    case "Link":
+                    case "Number":
+                    case "Range":
+                    case "Select":
+                    case "Separator":
+                    case "StructuredText":
+                    case "Table":
+                    case "Text":
+                    case "Timestamp":
+                        field = prevField;
+                        break;
+                }
+                acc[key] = onField({
+                    path,
+                    key,
+                    field,
+                });
+                return acc;
+            }, {}),
+        }),
+        ...(variation.items && {
+            items: Object.entries(variation.items).reduce((acc, [key, field]) => {
+                const path = prevPath.concat("items", key);
+                acc[key] = onField({
+                    path,
+                    key,
+                    field,
+                });
+                return acc;
+            }, {}),
+        }),
+    };
+}
+exports.traverseVariation = traverseVariation;
+function traverseSharedSlice(args) {
+    const { path: prevPath, slice, onField } = args;
+    return {
+        ...slice,
+        variations: slice.variations.map((variation) => {
+            const path = prevPath.concat(variation.id);
+            return traverseVariation({
+                path,
+                variation,
+                onField,
+            });
+        }),
+    };
+}
+exports.traverseSharedSlice = traverseSharedSlice;

package/lib/customtypes/widgets/slices/Slices.d.ts

@@ -1,4 +1,7 @@
 import * as t from "io-ts";
+import type { OnFieldFn } from "../../../_internal/utils";
+import { Group, NestedGroup } from "../Group";
+import type { NestableWidget } from "../nestable";
 import { SharedSlice } from "./SharedSlice";
 import { SharedSliceRef } from "./SharedSliceRef";
 export declare const LegacySlicesFieldType = "Choice";
@@ -5387,3 +5390,8 @@ export declare type DynamicSlices = t.TypeOf<typeof DynamicSlices>;
 export declare const Slices: {
     toStatic(slices: DynamicSlices, sharedSlices: Map<string, SharedSlice>): StaticSlices;
 };
+export declare function traverseSlices<T extends DynamicSlices | StaticSlices>(args: {
+    path: ReadonlyArray<string>;
+    slices: T;
+    onField: OnFieldFn<NestableWidget | Group | NestedGroup>;
+}): T;

package/lib/customtypes/widgets/slices/Slices.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Slices = exports.DynamicSlices = exports.StaticSlices = exports.slicesReader = exports.DynamicSlicesConfig = exports.StaticSlicesConfig = exports.slicesConfigReader = exports.SlicesLabels = exports.SlicesFieldType = exports.LegacySlicesFieldType = void 0;
+exports.traverseSlices = exports.Slices = exports.DynamicSlices = exports.StaticSlices = exports.slicesReader = exports.DynamicSlicesConfig = exports.StaticSlicesConfig = exports.slicesConfigReader = exports.SlicesLabels = exports.SlicesFieldType = exports.LegacySlicesFieldType = void 0;
 const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const common_1 = require("../../../common");
 const validators_1 = require("../../../validators");
+const Group_1 = require("../Group");
 const CompositeSlice_1 = require("./CompositeSlice");
 const LegacySlice_1 = require("./LegacySlice");
 const SharedSlice_1 = require("./SharedSlice");
@@ -78,3 +79,76 @@ exports.Slices = {
         }
     },
 };
+function traverseSlices(args) {
+    var _a;
+    const { path: prevPath, slices, onField } = args;
+    const choices = ((_a = slices.config) === null || _a === void 0 ? void 0 : _a.choices) &&
+        Object.entries(slices.config.choices).reduce((acc, [key, prevModel]) => {
+            const path = prevPath.concat(key);
+            let model;
+            switch (prevModel.type) {
+                case "Slice":
+                    model = (0, CompositeSlice_1.traverseCompositeSlice)({
+                        path,
+                        slice: prevModel,
+                        onField: onField,
+                    });
+                    break;
+                case "SharedSlice":
+                    if ("variations" in prevModel)
+                        model = (0, SharedSlice_1.traverseSharedSlice)({
+                            path,
+                            slice: prevModel,
+                            onField,
+                        });
+                    else
+                        model = prevModel;
+                    break;
+                case "Group":
+                    model = onField({
+                        path,
+                        key,
+                        field: (0, Group_1.traverseNestedGroup)({
+                            path,
+                            group: prevModel,
+                            onField: onField,
+                        }),
+                    });
+                    break;
+                case "Boolean":
+                case "Color":
+                case "Date":
+                case "Embed":
+                case "GeoPoint":
+                case "Image":
+                case "IntegrationFields":
+                case "Link":
+                case "Number":
+                case "Range":
+                case "Select":
+                case "Separator":
+                case "StructuredText":
+                case "Table":
+                case "Text":
+                case "Timestamp":
+                    model = onField({
+                        path,
+                        key,
+                        field: prevModel,
+                    });
+                    break;
+            }
+            acc[key] = model;
+            return acc;
+        }, {});
+    return {
+        ...slices,
+        ...(slices.config && {
+            config: {
+                ...slices.config,
+                ...(choices && { choices }),
+            },
+        }),
+    };
+}
+exports.traverseSlices = traverseSlices;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "3.9.0",
+	"version": "3.10.0-alpha.0",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",

package/src/_internal/utils.ts

@@ -8,6 +8,7 @@ import type {
 	CompositeSlice,
 	Group,
 	NestableWidget,
+	NestedGroup,
 	StaticSlices,
 	UID,
 	VariationFields,
@@ -91,3 +92,6 @@ export type SliceModel =
 	| NestableWidget
 	| CompositeSlice
 	| Group
+
+export type OnFieldFn<T extends UID | NestableWidget | Group | NestedGroup> =
+	(args: { path: ReadonlyArray<string>; key: string; field: T }) => T

package/src/customtypes/CustomType.ts

@@ -2,8 +2,15 @@ import { Either, left, right } from "fp-ts/lib/Either"
 import * as t from "io-ts"
 import { withFallback } from "io-ts-types/lib/withFallback"
 
+import type { OnFieldFn } from "../_internal/utils"
 import { StringOrNull } from "../validators"
-import { DynamicSection, Sections, StaticSection } from "./Section"
+import {
+	DynamicSection,
+	Sections,
+	StaticSection,
+	traverseSection,
+} from "./Section"
+import type { Group, NestableWidget, NestedGroup, UID } from "./widgets"
 import type { SharedSlice } from "./widgets/slices/SharedSlice"
 import type { DynamicSlice } from "./widgets/slices/Slice"
 import type { DynamicSlices } from "./widgets/slices/Slices"
@@ -245,3 +252,25 @@ export function collectSharedSlices(customType: {
 		return acc
 	}, {})
 }
+
+export function traverseCustomType<
+	T extends CustomType | StaticCustomType,
+>(args: {
+	customType: T
+	onField: OnFieldFn<UID | NestableWidget | Group | NestedGroup>
+}): T {
+	const { customType, onField } = args
+	return {
+		...customType,
+		json: Object.entries(customType.json).reduce<
+			Record<string, typeof customType.json[string]>
+		>((acc, [key, section]) => {
+			acc[key] = traverseSection({
+				path: [key],
+				section,
+				onField,
+			})
+			return acc
+		}, {}),
+	}
+}

package/src/customtypes/Section.ts

@@ -1,6 +1,15 @@
 import * as t from "io-ts"
 
+import type { OnFieldFn } from "../_internal/utils"
 import { WidgetKey } from "../common"
+import {
+	Group,
+	NestableWidget,
+	NestedGroup,
+	traverseGroup,
+	traverseSlices,
+	UID,
+} from "./widgets"
 import type { SharedSlice } from "./widgets/slices"
 import { DynamicWidget, StaticWidget, Widgets } from "./widgets/Widget"
 
@@ -33,3 +42,63 @@ export const Sections = {
 		return section as StaticSection
 	},
 }
+
+export function traverseSection<
+	T extends DynamicSection | StaticSection,
+>(args: {
+	path: ReadonlyArray<string>
+	section: T
+	onField: OnFieldFn<UID | NestableWidget | Group | NestedGroup>
+}): T {
+	const { path: prevPath, section, onField } = args
+	return Object.entries(section).reduce((acc, [key, prevModel]) => {
+		const path = prevPath.concat(key)
+		let model
+		switch (prevModel.type) {
+			case "Choice":
+			case "Slices":
+				model = traverseSlices({
+					path,
+					slices: prevModel,
+					onField: onField as OnFieldFn<NestableWidget | Group | NestedGroup>,
+				})
+				break
+			case "Group":
+				model = onField({
+					path,
+					key,
+					field: traverseGroup({
+						path,
+						group: prevModel,
+						onField: onField as OnFieldFn<NestableWidget | NestedGroup>,
+					}),
+				})
+				break
+			case "Boolean":
+			case "Color":
+			case "Date":
+			case "Embed":
+			case "GeoPoint":
+			case "Image":
+			case "IntegrationFields":
+			case "Link":
+			case "Number":
+			case "Range":
+			case "Select":
+			case "Separator":
+			case "StructuredText":
+			case "Table":
+			case "Text":
+			case "Timestamp":
+			case "UID":
+				model = onField({
+					path,
+					key,
+					field: prevModel,
+				})
+				break
+		}
+		acc[key] = model
+		return acc
+	}, {} as T)
+}

package/src/customtypes/widgets/Group.ts

@@ -1,5 +1,6 @@
 import * as t from "io-ts"
 
+import type { OnFieldFn } from "../../_internal/utils"
 import { WidgetKey } from "../../common"
 import { StringOrNull } from "../../validators"
 import { NestableWidget } from "./nestable/NestableWidget"
@@ -47,3 +48,92 @@ export type GroupConfig = t.TypeOf<typeof GroupConfig>
 
 export const Group = createGroup(t.union([NestableWidget, NestedGroup]))
 export type Group = t.TypeOf<typeof Group>
+
+export function traverseNestedGroup(args: {
+	path: ReadonlyArray<string>
+	group: NestedGroup
+	onField: OnFieldFn<NestableWidget>
+}): NestedGroup {
+	const { path: prevPath, group, onField } = args
+	const fields =
+		group.config?.fields &&
+		Object.entries(group.config.fields).reduce<Record<string, NestableWidget>>(
+			(acc, [key, model]) => {
+				const path = prevPath.concat(key)
+				acc[key] = onField({
+					path,
+					key,
+					field: model,
+				})
+				return acc
+			},
+			{},
+		)
+	return {
+		...group,
+		...(group.config && {
+			config: {
+				...group.config,
+				...(fields && { fields }),
+			},
+		}),
+	}
+}
+
+export function traverseGroup(args: {
+	path: ReadonlyArray<string>
+	group: Group
+	onField: OnFieldFn<NestableWidget | NestedGroup>
+}): Group {
+	const { path: prevPath, group, onField } = args
+	const fields =
+		group.config?.fields &&
+		Object.entries(group.config.fields).reduce<
+			Record<string, NestableWidget | NestedGroup>
+		>((acc, [key, prevField]) => {
+			const path = prevPath.concat(key)
+			let field
+			switch (prevField.type) {
+				case "Group":
+					field = traverseNestedGroup({
+						path,
+						group: prevField,
+						onField: onField as OnFieldFn<NestableWidget>,
+					})
+					break
+				case "Boolean":
+				case "Color":
+				case "Date":
+				case "Embed":
+				case "GeoPoint":
+				case "Image":
+				case "IntegrationFields":
+				case "Link":
+				case "Number":
+				case "Range":
+				case "Select":
+				case "Separator":
+				case "StructuredText":
+				case "Table":
+				case "Text":
+				case "Timestamp":
+					field = prevField
+					break
+			}
+			acc[key] = onField({
+				path,
+				key,
+				field,
+			})
+			return acc
+		}, {})
+	return {
+		...group,
+		...(group.config && {
+			config: {
+				...group.config,
+				...(fields && { fields }),
+			},
+		}),
+	}
+}

package/src/customtypes/widgets/slices/CompositeSlice.ts

@@ -1,5 +1,6 @@
 import * as t from "io-ts"
 
+import type { OnFieldFn } from "../../../_internal/utils"
 import { WidgetKey } from "../../../common"
 import { StringOrNull } from "../../../validators"
 import { NestableWidget } from "../nestable/NestableWidget"
@@ -37,3 +38,40 @@ export function isCompositeSlice(
 ): slice is CompositeSlice {
 	return slice.type === "Slice"
 }
+
+export function traverseCompositeSlice(args: {
+	path: ReadonlyArray<string>
+	slice: CompositeSlice
+	onField: OnFieldFn<NestableWidget>
+}): CompositeSlice {
+	const { path: prevPath, slice, onField } = args
+	const nonRepeat =
+		slice["non-repeat"] &&
+		Object.entries(slice["non-repeat"]).reduce<Record<string, NestableWidget>>(
+			(acc, [key, field]) => {
+				const path = prevPath.concat("non-repeat", key)
+				acc[key] = onField({ path, key, field })
+				return acc
+			},
+			{},
+		)
+	const repeat =
+		slice.repeat &&
+		Object.entries(slice.repeat).reduce<Record<string, NestableWidget>>(
+			(acc, [key, field]) => {
+				const path = prevPath.concat("repeat", key)
+				acc[key] = onField({ path, key, field })
+				return acc
+			},
+			{},
+		)
+	return {
+		...slice,
+		...(nonRepeat && {
+			"non-repeat": nonRepeat,
+		}),
+		...(repeat && {
+			repeat,
+		}),
+	}
+}