@prismicio/types-internal 2.2.0-traverse.alpha-0 → 2.2.0-traverse.alpha-2

package/src/content/fields/slices/Slice/SimpleSliceContent.ts

@@ -1,12 +1,31 @@
 import * as t from "io-ts"
 
+import type {
+	ContentPath,
+	TraverseSliceContentFn,
+	TraverseWidgetContentFn,
+} from "../../../../_internal/utils"
+import type {
+	Group,
+	NestableWidget,
+	VariationFields,
+} from "../../../../customtypes"
 import type { LegacyContentCtx } from "../../../LegacyContentCtx"
-import { GroupContent, GroupLegacy, isGroupContent } from "../../GroupContent"
+import {
+	GroupContent,
+	GroupLegacy,
+	isGroupContent,
+	traverseGroupContent,
+} from "../../GroupContent"
 import {
 	isNestableContent,
 	NestableContent,
 	NestableLegacy,
 } from "../../nestable"
+import type {
+	SharedSliceItemContent,
+	SimpleSliceItemContent,
+} from "../SliceItem"
 
 export const SimpleSliceContent = t.union([NestableContent, GroupContent])
 export type SimpleSliceContent = t.TypeOf<typeof SimpleSliceContent>
@@ -31,3 +50,82 @@ export const SimpleSliceLegacy = (ctx: LegacyContentCtx) => {
 		},
 	}
 }
+
+export function traverseSimpleSliceContent({
+	path,
+	sliceKey,
+	sliceName,
+	model,
+	content,
+}: {
+	path: ContentPath
+	sliceKey: string
+	sliceName: string
+	content: SimpleSliceItemContent
+	model?: VariationFields | Group | NestableWidget | undefined
+}) {
+	return (
+		transformWidget: TraverseWidgetContentFn,
+		transformSlice: TraverseSliceContentFn,
+	): SharedSliceItemContent | SimpleSliceItemContent | undefined => {
+		if (isGroupContent(content.widget)) {
+			const convertedGroupWidget: GroupContent | undefined =
+				traverseGroupContent({
+					path,
+					key: content.key,
+					apiId: content.name,
+					model: (() => {
+						if (model?.type === "Group") return model
+						if (model?.type === "SharedSlice")
+							return {
+								type: "Group",
+								config: { fields: model.fields.items || {} },
+							}
+						return
+					})(),
+					content: content.widget,
+				})(transformWidget)
+
+			return (
+				convertedGroupWidget &&
+				transformSlice({
+					key: content.key,
+					apiId: content.name,
+					path,
+					model,
+					content: {
+						...content,
+						widget: convertedGroupWidget,
+					},
+				})
+			)
+		}
+
+		const convertedNestable: NestableContent | undefined = transformWidget({
+			key: content.key,
+			apiId: content.name,
+			path,
+			model: (() => {
+				if (model?.type === "SharedSlice")
+					return model.fields.primary?.[content.name]
+				if (model?.type !== "Group") return model
+				return
+			})(),
+			content: content.widget,
+		})
+
+		return (
+			convertedNestable &&
+			transformSlice({
+				key: sliceKey,
+				apiId: sliceName,
+				path,
+				model,
+				content: {
+					...content,
+					widget: convertedNestable,
+				},
+			})
+		)
+	}
+}

package/src/content/fields/slices/SliceItem.ts

@@ -9,10 +9,21 @@ import {
 	LegacyContentCtx,
 	WithTypes,
 } from "../../LegacyContentCtx"
+import { isGroupContent } from "../GroupContent"
+import { isNestableContent } from "../nestable"
 import { SliceContent, SliceLegacy } from "./Slice"
-import { isCompositeSliceContent } from "./Slice/CompositeSliceContent"
-import { isSharedSliceContent } from "./Slice/SharedSliceContent"
-import { isSimpleSliceContent } from "./Slice/SimpleSliceContent"
+import {
+	CompositeSliceContent,
+	isCompositeSliceContent,
+} from "./Slice/CompositeSliceContent"
+import {
+	isSharedSliceContent,
+	SharedSliceContent,
+} from "./Slice/SharedSliceContent"
+import {
+	isSimpleSliceContent,
+	SimpleSliceContent,
+} from "./Slice/SimpleSliceContent"
 
 export const SliceItemContent = t.type({
 	key: t.string,
@@ -21,6 +32,31 @@ export const SliceItemContent = t.type({
 	widget: SliceContent,
 })
 export type SliceItemContent = t.TypeOf<typeof SliceItemContent>
+export type SharedSliceItemContent = Omit<SliceItemContent, "widget"> & {
+	widget: SharedSliceContent
+}
+export function isSharedSliceItemContent(
+	item: SliceItemContent,
+): item is SharedSliceItemContent {
+	return isSharedSliceContent(item.widget)
+}
+
+export type CompositeSliceItemContent = Omit<SliceItemContent, "widget"> & {
+	widget: CompositeSliceContent
+}
+export function isCompositeSliceItemContent(
+	item: SliceItemContent,
+): item is CompositeSliceItemContent {
+	return isCompositeSliceContent(item.widget)
+}
+export type SimpleSliceItemContent = Omit<SliceItemContent, "widget"> & {
+	widget: SimpleSliceContent
+}
+export function isSimpleSliceItemContent(
+	item: SliceItemContent,
+): item is SimpleSliceItemContent {
+	return isGroupContent(item.widget) || isNestableContent(item.widget)
+}
 
 const itemLegacyReader = t.exact(
 	t.intersection([

package/src/content/fields/slices/SlicesContent.ts

@@ -2,13 +2,22 @@ import { either } from "fp-ts"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
-import type { ContentPath, TraverseContentFn } from "../../../_internal/utils"
 import {
-	type StaticSlice,
+	ContentPath,
+	SliceModel,
+	TraverseSliceContentFn,
+	TraverseWidgetContentFn,
+} from "../../../_internal/utils"
+import {
 	type StaticSlices,
+	CompositeSliceFields,
+	Group,
 	isCompositeSlice,
 	isLegacySlice,
 	isStaticSharedSlice,
+	NestableWidget,
+	SharedSlice,
+	VariationFields,
 } from "../../../customtypes"
 import type {
 	FieldOrSliceType,
@@ -16,10 +25,16 @@ import type {
 	WithTypes,
 } from "../../LegacyContentCtx"
 import { hasContentType } from "../../utils"
-import { traverseGroupContent } from "../GroupContent"
 import { traverseCompositeSliceContent } from "./Slice/CompositeSliceContent"
 import { traverseSharedSliceContent } from "./Slice/SharedSliceContent"
-import { SliceItemContent, SlicesItemLegacy } from "./SliceItem"
+import { traverseSimpleSliceContent } from "./Slice/SimpleSliceContent"
+import {
+	isCompositeSliceItemContent,
+	isSharedSliceItemContent,
+	isSimpleSliceItemContent,
+	SliceItemContent,
+	SlicesItemLegacy,
+} from "./SliceItem"
 
 export const SlicesContentType = "SliceContentType"
 
@@ -66,87 +81,175 @@ export const SlicesContent = t.type({
 
 export type SlicesContent = t.TypeOf<typeof SlicesContent>
 
+function findSliceModel(
+	slicesPath: ContentPath,
+	model: StaticSlices,
+	content: SliceItemContent,
+): SliceModel | undefined {
+	const defaultModel = model?.config?.choices?.[content.name]
+
+	// regular case for shared slices
+	const sharedSliceModel = (): VariationFields | undefined => {
+		if (isSharedSliceItemContent(content)) {
+			if (defaultModel && isStaticSharedSlice(defaultModel)) {
+				const variationDef = defaultModel.variations.find(
+					(v) => v.id === content.widget.variation,
+				)
+				return variationDef
+					? {
+							type: "SharedSlice",
+							sliceName: defaultModel.id,
+							variationId: variationDef.id,
+							fields: {
+								primary: variationDef.primary || {},
+								items: variationDef.items || {},
+							},
+					  }
+					: undefined
+			}
+		}
+		return
+	}
+
+	const migratedSliceModel = (): VariationFields | undefined => {
+		const legacyContentPath = ContentPath.append(
+			ContentPath.serialize(slicesPath),
+			content.name,
+		)
+
+		const migratedSliceModel = Object.values(model?.config?.choices || {}).find(
+			(sliceModel): sliceModel is SharedSlice => {
+				if (isStaticSharedSlice(sliceModel)) {
+					return !!sliceModel.legacyPaths?.[legacyContentPath]
+				}
+
+				return false
+			},
+		)
+		if (!migratedSliceModel) return
+
+		const migratedVariation = migratedSliceModel?.variations.find(
+			(v) => v.id === migratedSliceModel.legacyPaths?.[legacyContentPath],
+		)
+		if (!migratedVariation) return
+
+		return {
+			type: "SharedSlice",
+			sliceName: migratedSliceModel.id,
+			variationId: migratedVariation.id,
+			fields: {
+				primary: migratedVariation.primary || {},
+				items: migratedVariation.items || {},
+			},
+		}
+	}
+
+	const legacySliceModel = ():
+		| NestableWidget
+		| CompositeSliceFields
+		| Group
+		| undefined => {
+		if (!defaultModel) return
+
+		if (isCompositeSlice(defaultModel)) {
+			return {
+				type: "Slice",
+				fields: {
+					"non-repeat": defaultModel["non-repeat"] || {},
+					repeat: defaultModel.repeat || {},
+				},
+			}
+		}
+		if (isLegacySlice(defaultModel)) {
+			return defaultModel
+		}
+
+		return
+	}
+	return sharedSliceModel() || migratedSliceModel() || legacySliceModel()
+}
+
 export function traverseSlices({
 	path,
+	key,
 	model,
 	content,
 }: {
 	path: ContentPath
+	key: string
 	content: SlicesContent
 	model?: StaticSlices | undefined
 }) {
-	return (transform: TraverseContentFn): SlicesContent | undefined => {
+	return (
+		transformWidget: TraverseWidgetContentFn,
+		transformSlice: TraverseSliceContentFn,
+	): SlicesContent | undefined => {
 		const value = content.value.reduce<SlicesContent["value"]>(
 			(acc, sliceContent) => {
-				const sliceModel: StaticSlice | undefined =
-					model?.config?.choices?.[sliceContent.name]
-
-				const slicePath = path.concat({
-					key: sliceContent.key,
-					type: sliceContent.widget.__TYPE__,
-				})
-
-				const convertedSliceWidget = (() => {
-					switch (sliceContent.widget.__TYPE__) {
-						case "SharedSliceContent":
-							return traverseSharedSliceContent({
-								path: slicePath,
-								sliceName: sliceContent.name,
-								model:
-									sliceModel && isStaticSharedSlice(sliceModel)
-										? sliceModel
-										: undefined,
-								content: sliceContent.widget,
-							})(transform)
-						case "CompositeSliceContent":
-							return traverseCompositeSliceContent({
-								path: slicePath,
-								sliceName: sliceContent.name,
-								model:
-									sliceModel && isCompositeSlice(sliceModel)
-										? sliceModel
-										: undefined,
-								content: sliceContent.widget,
-							})(transform)
-						case "GroupContentType":
-							return traverseGroupContent({
-								path: slicePath,
-								model:
-									sliceModel &&
-									isLegacySlice(sliceModel) &&
-									sliceModel.type === "Group"
-										? sliceModel
-										: undefined,
-								content: sliceContent.widget,
-							})(transform)
-						default:
-							return sliceContent.widget
-					}
+				const sliceModel = model && findSliceModel(path, model, sliceContent)
+
+				const convertedSlice: SliceItemContent | undefined = (() => {
+					if (isSharedSliceItemContent(sliceContent))
+						return traverseSharedSliceContent({
+							path: path.concat({
+								key: sliceContent.key,
+								type: "SharedSlice",
+							}),
+							sliceKey: sliceContent.key,
+							sliceName: sliceContent.name,
+							model:
+								sliceModel?.type === "SharedSlice" ? sliceModel : undefined,
+							content: sliceContent,
+						})(transformWidget, transformSlice)
+
+					if (isCompositeSliceItemContent(sliceContent))
+						return traverseCompositeSliceContent({
+							path: path.concat({
+								key: sliceContent.key,
+								type: "Slice",
+							}),
+							sliceKey: sliceContent.key,
+							sliceName: sliceContent.name,
+							model:
+								sliceModel?.type === "Slice" ||
+								sliceModel?.type === "SharedSlice"
+									? sliceModel
+									: undefined,
+							content: sliceContent,
+						})(transformWidget, transformSlice)
+
+					if (isSimpleSliceItemContent(sliceContent))
+						return traverseSimpleSliceContent({
+							path: path.concat({
+								key: sliceContent.key,
+								type: "LegacySlice",
+							}),
+							sliceKey: sliceContent.key,
+							sliceName: sliceContent.name,
+							model:
+								sliceModel && sliceModel?.type !== "Slice"
+									? sliceModel
+									: undefined,
+							content: sliceContent,
+						})(transformWidget, transformSlice)
+
+					return
 				})()
 
-				if (!convertedSliceWidget) return acc
-
-				const convertedSlice = transform({
-					key: sliceContent.key,
-					apiId: sliceContent.name,
-					path: slicePath,
-					model: sliceModel,
-					content: convertedSliceWidget,
-				})
-
-				const convertedSliceParent = convertedSlice && {
-					...sliceContent,
-					widget: convertedSlice,
-				}
-
-				return convertedSliceParent ? acc.concat(convertedSliceParent) : acc
+				return convertedSlice ? acc.concat(convertedSlice) : acc
 			},
 			[],
 		)
 
-		return {
-			__TYPE__: content.__TYPE__,
-			value,
-		}
+		return transformWidget({
+			path,
+			key,
+			apiId: key,
+			model,
+			content: {
+				__TYPE__: content.__TYPE__,
+				value,
+			},
+		})
 	}
 }

package/src/customtypes/CustomType.ts

@@ -224,3 +224,24 @@ export function flattenCustomTypeFields(
 		{},
 	)
 }
+
+export function collectSharedSlices(
+	customType: StaticCustomType,
+): Record<string, SharedSlice> {
+	return flattenStaticWidgets(customType).reduce((acc, [, w]) => {
+		if (w.type === "Slices" || w.type === "Choice") {
+			return {
+				...acc,
+				...Object.entries(w.config?.choices || {}).reduce(
+					(sliceZoneAcc, [sliceKey, sliceModel]) => {
+						return sliceModel.type === "SharedSlice"
+							? { ...sliceZoneAcc, [sliceKey]: sliceModel }
+							: sliceZoneAcc
+					},
+					{},
+				),
+			}
+		}
+		return acc
+	}, {})
+}

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

@@ -1,5 +1,6 @@
 import * as t from "io-ts"
 
+import type { PickOnly } from "../../../_internal/utils"
 import { WidgetKey } from "../../../common"
 import { StringOrNull } from "../../../validators"
 import { NestableWidget } from "../nestable/NestableWidget"
@@ -32,6 +33,11 @@ export const CompositeSlice = t.exact(
 )
 export type CompositeSlice = t.TypeOf<typeof CompositeSlice>
 
+export type CompositeSliceFields = {
+	type: "Slice"
+	fields: PickOnly<CompositeSlice, "non-repeat" | "repeat">
+}
+
 export function isCompositeSlice(
 	slice: DynamicSlice | StaticSlice,
 ): slice is CompositeSlice {

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

@@ -1,6 +1,7 @@
 import * as t from "io-ts"
 import { withFallback } from "io-ts-types/lib/withFallback"
 
+import type { PickOnly } from "../../../_internal/utils"
 import { WidgetKey } from "../../../common"
 import { NestableWidget } from "../nestable/NestableWidget"
 import type { SharedSliceRef } from "./SharedSliceRef"
@@ -29,8 +30,18 @@ export const Variation = t.exact(
 
 export type Variation = t.TypeOf<typeof Variation>
 
+export type VariationFields = {
+	type: "SharedSlice"
+	sliceName: string
+	variationId: string
+	fields: PickOnly<Variation, "primary" | "items">
+}
+
 export const SharedSliceType = "SharedSlice"
 
+const LegacyPath = t.string
+const VariationId = t.string
+
 export const SharedSlice = t.exact(
 	t.intersection([
 		t.type({
@@ -41,6 +52,7 @@ export const SharedSlice = t.exact(
 		}),
 		t.partial({
 			description: t.string,
+			legacyPaths: t.record(LegacyPath, VariationId),
 		}),
 	]),
 )

package/lib/validators/NullOrT.d.ts

@@ -1,2 +0,0 @@
-import * as t from "io-ts";
-export declare const NullOrElse: <A, O = A>(codec: t.Type<A, O, unknown>) => t.Type<A | null, O | undefined, unknown>;

package/lib/validators/NullOrT.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NullOrElse = void 0;
-const tslib_1 = require("tslib");
-const Either_1 = require("fp-ts/lib/Either");
-const t = (0, tslib_1.__importStar)(require("io-ts"));
-const NullOrElse = (codec) => new t.Type("NullOrT", (u) => null === u || codec.is(u), (u) => {
-    if ((0, Either_1.isRight)(t.null.decode(u)))
-        return t.success(null);
-    return codec.decode(u);
-}, (chunk) => (chunk ? codec.encode(chunk) : undefined));
-exports.NullOrElse = NullOrElse;