@prismicio/types-internal 3.17.0 → 4.0.0-canary.65d3262

package/src/content/fields/GroupContent.ts

@@ -1,466 +0,0 @@
-import { array, either } from "fp-ts"
-import { isLeft } from "fp-ts/lib/Either"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import {
-	type Group,
-	type NestableWidget,
-	type NestedGroup,
-	GroupFieldType,
-} from "../../customtypes"
-import {
-	FieldOrSliceType,
-	getFieldCtx,
-	LegacyContentCtx,
-	WithTypes,
-} from "../LegacyContentCtx"
-import {
-	ContentPath,
-	hasContentType,
-	TraverseWidgetContentFn,
-	TraverseWidgetContentWithModelFn,
-} from "../utils"
-import {
-	isNestableContent,
-	isRepeatableContent,
-	isTableContent,
-	NestableContent,
-	NestableLegacy,
-	traverseRepeatableContent,
-	traverseRepeatableContentWithModel,
-	traverseTableContent,
-	traverseTableContentWithModel,
-} from "./nestable"
-import { repeatableContentWithDefaultNestableContentValues } from "./withDefaultValues"
-
-export const GroupItemContentType = "GroupItemContent" as const
-export const GroupContentType = "GroupContentType" as const
-
-export const GroupItemContent: t.Type<GroupItemContent> = t.recursion(
-	"GroupItemContent",
-	() =>
-		t.strict({
-			__TYPE__: t.literal(GroupItemContentType),
-			key: t.string,
-			value: t.array(
-				t.tuple([t.string, t.union([NestableContent, GroupContent])]),
-			),
-		}),
-)
-export type GroupItemContent = {
-	__TYPE__: typeof GroupItemContentType
-	key: string
-	value: [string, NestableContent | GroupContent][]
-}
-
-export const GroupContent: t.Type<GroupContent> = t.recursion(
-	"GroupContent",
-	() =>
-		t.strict({
-			__TYPE__: t.literal(GroupContentType),
-			value: t.array(GroupItemContent),
-		}),
-)
-export type GroupContent = {
-	__TYPE__: typeof GroupContentType
-	value: GroupItemContent[]
-}
-
-export const isGroupContent = (u: unknown): u is GroupContent =>
-	hasContentType(u) && u.__TYPE__ === GroupContentType
-
-export const GroupContentDefaultValue: GroupContent = {
-	__TYPE__: GroupContentType,
-	value: [],
-}
-
-const itemLegacyReader = t.record(t.string, t.unknown)
-export type GroupItemLegacy = t.TypeOf<typeof itemLegacyReader>
-
-export const GroupItemLegacy = (ctx: LegacyContentCtx, index: number) => {
-	return new t.Type<GroupItemContent, WithTypes<GroupItemLegacy>>(
-		"GroupItemLegacy",
-		(u): u is GroupItemContent =>
-			hasContentType(u) && u.__TYPE__ === GroupItemContentType,
-		(u) => {
-			const parsed = pipe(
-				itemLegacyReader.decode(u),
-				either.map((items) => {
-					const groupItemCtx = ctx.withContentKey(`${index}`)
-					const parsedItems = Object.entries(items).reduce<
-						Array<[string, NestableContent | GroupContent]>
-					>((acc, [itemKey, itemValue]) => {
-						const itemCtx = getFieldCtx({
-							fieldKey: itemKey,
-							contentKey: itemKey,
-							ctx: groupItemCtx,
-						})
-						const result =
-							itemCtx.fieldType === GroupFieldType
-								? GroupLegacy(itemCtx).decode(itemValue)
-								: NestableLegacy(itemCtx).decode(itemValue)
-
-						if (!result) return acc
-
-						if (isLeft(result)) return acc
-						return [...acc, [itemKey, result.right]]
-					}, [])
-
-					return {
-						value: parsedItems,
-						__TYPE__: GroupItemContentType,
-						key: groupItemCtx.fieldContentKey,
-					}
-				}),
-			)
-			return parsed
-		},
-		(item) => {
-			const groupItemCtx = ctx.withContentKey(`${index}`)
-			return item.value.reduce<WithTypes<GroupItemLegacy>>(
-				(acc, [key, value]) => {
-					const itemCtx = getFieldCtx({ fieldKey: key, ctx })
-					const encoded = isGroupContent(value)
-						? GroupLegacy(itemCtx).encode(value)
-						: NestableLegacy(itemCtx).encode(value)
-
-					if (!encoded) return acc
-
-					return {
-						content: { ...acc.content, [key]: encoded.content },
-						types: { ...acc.types, ...encoded.types },
-						keys: { ...acc.keys, ...encoded.keys },
-					}
-				},
-				{ content: {}, types: {}, keys: { [groupItemCtx.keyOfKey]: item.key } },
-			)
-		},
-	)
-}
-
-export function arrayWithIndexCodec<T, O>(
-	f: (index: number) => t.Type<T, O, unknown>,
-): t.Type<Array<T>, O[], unknown> {
-	return new t.Type<Array<T>, O[], unknown>(
-		"ArrayWithIndexCodec",
-		(u): u is Array<T> => Array.isArray(u),
-		(items) =>
-			pipe(
-				t.array(t.unknown).decode(items),
-				either.chain((validItems) => {
-					const decodedItems = validItems.map((item, index) => {
-						return f(index).decode(item)
-					})
-					return array.sequence(either.Applicative)(decodedItems)
-				}),
-			),
-		(items) => items.map((item, index) => f(index).encode(item)),
-	)
-}
-
-type GroupLegacy = Array<GroupItemLegacy>
-export const GroupLegacy = (
-	ctx: LegacyContentCtx,
-): t.Type<GroupContent, WithTypes<GroupLegacy>, unknown> => {
-	const codecDecode = arrayWithIndexCodec<
-		GroupItemContent | null,
-		WithTypes<GroupItemLegacy> | null
-	>((index) => t.union([GroupItemLegacy(ctx, index), t.null]))
-
-	const codecEncode = (items: GroupItemContent[]) =>
-		items.map((item, index) => GroupItemLegacy(ctx, index).encode(item))
-
-	return new t.Type<GroupContent, WithTypes<GroupLegacy>, unknown>(
-		"GroupLegacy",
-		isGroupContent,
-		(items) => {
-			return pipe(
-				codecDecode.decode(items),
-				either.map((parsedItems) => {
-					const value = parsedItems.map((i, index) => {
-						if (i === null) {
-							const key = ctx.withContentKey(`${index}`).fieldContentKey
-							return { __TYPE__: GroupItemContentType, key, value: [] }
-						}
-						return i
-					})
-					return {
-						value,
-						__TYPE__: GroupContentType,
-					}
-				}),
-			)
-		},
-		(g: GroupContent) => {
-			const res = codecEncode(g.value)
-			return {
-				content: res.map((block) => block.content),
-				types: res.reduce<Record<string, FieldOrSliceType>>(
-					(acc, block) => {
-						return { ...acc, ...block.types }
-					},
-					{ [ctx.keyOfType]: GroupFieldType },
-				),
-				keys: res.reduce<Record<string, string>>((acc, block) => {
-					return { ...acc, ...block.keys }
-				}, {}),
-			}
-		},
-	)
-}
-
-export function groupContentWithDefaultValues(
-	customType: Group,
-	content: GroupContent,
-): GroupContent {
-	const fields = customType.config?.fields
-	if (!fields) return content
-	return {
-		...content,
-		value: repeatableContentWithDefaultNestableContentValues(
-			fields,
-			content.value,
-		),
-	}
-}
-
-export function traverseGroupContent({
-	path,
-	key,
-	apiId,
-	model,
-	content,
-}: {
-	path: ContentPath
-	key: string
-	apiId: string
-	content: GroupContent
-	model?: Group | undefined
-}) {
-	return (transform: TraverseWidgetContentFn): GroupContent | undefined => {
-		const groupItems = traverseGroupItemsContent({
-			path,
-			model: model?.config?.fields,
-			content: content.value,
-		})(transform)
-
-		return transform({
-			path,
-			key,
-			apiId,
-			model,
-			content: {
-				__TYPE__: content.__TYPE__,
-				value: groupItems,
-			},
-		})
-	}
-}
-
-export function traverseGroupItemsContent({
-	path,
-	model,
-	content,
-}: {
-	path: ContentPath
-	content: Array<GroupItemContent>
-	model?: Record<string, Group | NestableWidget> | undefined
-}) {
-	return (transform: TraverseWidgetContentFn): Array<GroupItemContent> => {
-		return content.map((groupItem) => {
-			const groupItemPath = path.concat([
-				{ key: groupItem.key, type: "GroupItem" },
-			])
-
-			const groupItemFields = groupItem.value.reduce<GroupItemContent["value"]>(
-				(acc, [fieldKey, fieldContent]) => {
-					const fieldDef = model?.[fieldKey]
-
-					let transformedField
-					if (isGroupContent(fieldContent)) {
-						transformedField = traverseGroupContent({
-							path: groupItemPath.concat([{ key: fieldKey, type: "Widget" }]),
-							key: fieldKey,
-							apiId: fieldKey,
-							model: fieldDef?.type === "Group" ? fieldDef : undefined,
-							content: fieldContent,
-						})(transform)
-					} else if (isRepeatableContent(fieldContent)) {
-						transformedField = traverseRepeatableContent({
-							path: groupItemPath.concat([{ key: fieldKey, type: "Widget" }]),
-							key: fieldKey,
-							apiId: fieldKey,
-							model: fieldDef?.type === "Link" ? fieldDef : undefined,
-							content: fieldContent,
-						})(transform)
-					} else if (isTableContent(fieldContent)) {
-						transformedField = traverseTableContent({
-							path: groupItemPath.concat([{ key: fieldKey, type: "Widget" }]),
-							key: fieldKey,
-							apiId: fieldKey,
-							model: fieldDef?.type === "Table" ? fieldDef : undefined,
-							content: fieldContent,
-						})(transform)
-					} else {
-						transformedField = transform({
-							path: groupItemPath.concat([{ key: fieldKey, type: "Widget" }]),
-							key: fieldKey,
-							apiId: fieldKey,
-							model: fieldDef,
-							content: fieldContent,
-						})
-					}
-
-					// Can happen if the transform function returns undefined to filter out a field
-					if (
-						!transformedField ||
-						!(
-							isNestableContent(transformedField) ||
-							isGroupContent(transformedField)
-						)
-					)
-						return acc
-
-					return acc.concat([[fieldKey, transformedField]])
-				},
-				[],
-			)
-
-			return {
-				__TYPE__: groupItem.__TYPE__,
-				key: groupItem.key,
-				value: groupItemFields,
-			}
-		})
-	}
-}
-
-export function traverseGroupContentWithModel({
-	path,
-	key,
-	model,
-	content,
-}: {
-	path: ContentPath
-	key: string
-	model: Group
-	content: GroupContent | undefined
-}): (transform: TraverseWidgetContentWithModelFn) => GroupContent | undefined {
-	return (transform) => {
-		const groupItems = traverseGroupItemsContentWithModel({
-			path,
-			model: model.config?.fields ?? {},
-			content: content?.value,
-		})(transform)
-
-		return transform({
-			path,
-			key,
-			apiId: key,
-			model,
-			content: content
-				? {
-						__TYPE__: content.__TYPE__,
-						value: groupItems,
-				  }
-				: undefined,
-		})
-	}
-}
-
-export function traverseGroupItemsContentWithModel({
-	path,
-	model,
-	content,
-}: {
-	path: ContentPath
-	model: Record<string, NestableWidget | Group | NestedGroup>
-	content: Array<GroupItemContent> | undefined
-}): (transform: TraverseWidgetContentWithModelFn) => Array<GroupItemContent> {
-	return (transform) => {
-		if (!content) return []
-
-		return content.map((groupItem) => {
-			const groupItemPath = path.concat([
-				{ key: groupItem.key, type: "GroupItem" },
-			])
-
-			const groupItemFields = Object.entries(model).reduce<
-				GroupItemContent["value"]
-			>((acc, [fieldKey, fieldModel]) => {
-				const fieldContent = groupItem.value.find(
-					([key]) => key === fieldKey,
-				)?.[1]
-
-				const fieldPath = groupItemPath.concat([
-					{ key: fieldKey, type: "Widget" },
-				])
-
-				let transformedField: NestableContent | GroupContent | undefined
-				if (fieldModel.type === "Group") {
-					const groupContent = isGroupContent(fieldContent)
-						? fieldContent
-						: undefined
-					transformedField = traverseGroupContentWithModel({
-						path: fieldPath,
-						key: fieldKey,
-						model: fieldModel,
-						content: groupContent,
-					})(transform)
-				} else if (
-					fieldModel.type === "Link" &&
-					fieldModel.config?.repeat === true
-				) {
-					const repeatableContent = isRepeatableContent(fieldContent)
-						? fieldContent
-						: undefined
-					transformedField = traverseRepeatableContentWithModel({
-						path: fieldPath,
-						key: fieldKey,
-						model: fieldModel,
-						content: repeatableContent,
-					})(transform)
-				} else if (fieldModel.type === "Table") {
-					const tableContent = isTableContent(fieldContent)
-						? fieldContent
-						: undefined
-					transformedField = traverseTableContentWithModel({
-						path: fieldPath,
-						key: fieldKey,
-						model: fieldModel,
-						content: tableContent,
-					})(transform)
-				} else {
-					const nestableContent = isNestableContent(fieldContent)
-						? fieldContent
-						: undefined
-					transformedField = transform({
-						path: fieldPath,
-						key: fieldKey,
-						apiId: fieldKey,
-						model: fieldModel,
-						content: nestableContent,
-					})
-				}
-
-				if (
-					!transformedField ||
-					!(
-						isNestableContent(transformedField) ||
-						isGroupContent(transformedField)
-					)
-				)
-					return acc
-
-				return acc.concat([[fieldKey, transformedField]])
-			}, [])
-
-			return {
-				__TYPE__: groupItem.__TYPE__,
-				key: groupItem.key,
-				value: groupItemFields,
-			}
-		})
-	}
-}

package/src/content/fields/UIDContent.ts

@@ -1,42 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import type { LegacyContentCtx, WithTypes } from "../LegacyContentCtx"
-import { hasContentType } from "../utils"
-
-export const UIDContentType = "UIDContent"
-
-export const isUIDContent = (u: unknown): u is UIDContent =>
-	hasContentType(u) && u.__TYPE__ === UIDContentType
-
-type UIDLegacy = string
-
-export const UIDLegacy = (ctx: LegacyContentCtx) =>
-	new t.Type<UIDContent, WithTypes<UIDLegacy>, unknown>(
-		"UIDLegacy",
-		isUIDContent,
-		(u) => {
-			return pipe(
-				t.string.decode(u),
-				either.map((uid) =>
-					UIDContent.encode({ value: uid, __TYPE__: UIDContentType }),
-				),
-			)
-		},
-
-		(uid: UIDContent) => {
-			return {
-				content: uid.value,
-				types: { [ctx.keyOfType]: "UID" },
-				keys: {},
-			}
-		},
-	)
-
-export const UIDContent = t.type({
-	__TYPE__: t.literal(UIDContentType),
-	value: t.string,
-})
-
-export type UIDContent = t.TypeOf<typeof UIDContent>

package/src/content/fields/WidgetContent.ts

@@ -1,76 +0,0 @@
-import * as t from "io-ts"
-
-import type { LegacyContentCtx } from "../LegacyContentCtx"
-import {
-	GroupContent,
-	GroupContentType,
-	GroupLegacy,
-	isGroupContent,
-} from "./GroupContent"
-import { isNestableContent, NestableContent, NestableLegacy } from "./nestable"
-import {
-	isSlicesContent,
-	SlicesContent,
-	SlicesContentType,
-	SlicesLegacy,
-} from "./slices"
-import {
-	isUIDContent,
-	UIDContent,
-	UIDContentType,
-	UIDLegacy,
-} from "./UIDContent"
-
-export const WidgetContent = t.union([
-	GroupContent,
-	NestableContent,
-	UIDContent,
-	SlicesContent,
-])
-
-export const isWidgetContent = (u: unknown): u is WidgetContent =>
-	isGroupContent(u) ||
-	isNestableContent(u) ||
-	isUIDContent(u) ||
-	isSlicesContent(u)
-
-export type WidgetContent = t.TypeOf<typeof WidgetContent>
-export type ContentType = WidgetContent["__TYPE__"]
-
-export const WidgetLegacy = (ctx: LegacyContentCtx) => {
-	return {
-		decode(value: unknown) {
-			if (!ctx.fieldType) return
-
-			const codec = (() => {
-				switch (ctx.fieldType) {
-					case "UID":
-						return UIDLegacy(ctx)
-					case "Group":
-						return GroupLegacy(ctx)
-					case "Choice":
-					case "Slices":
-						return SlicesLegacy(ctx)
-					default:
-						return NestableLegacy(ctx)
-				}
-			})()
-
-			if (!codec) return
-
-			return codec.decode(value)
-		},
-		encode(value: WidgetContent) {
-			switch (value.__TYPE__) {
-				case UIDContentType:
-					return UIDLegacy(ctx).encode(value)
-				case GroupContentType:
-					return GroupLegacy(ctx).encode(value)
-				case SlicesContentType:
-					return SlicesLegacy(ctx).encode(value)
-				default:
-					return NestableLegacy(ctx).encode(value)
-			}
-		},
-	}
-}

package/src/content/fields/index.ts

@@ -1,6 +0,0 @@
-export * from "./EmptyContent"
-export * from "./GroupContent"
-export * from "./nestable"
-export * from "./slices"
-export * from "./UIDContent"
-export * from "./WidgetContent"

package/src/content/fields/nestable/BooleanContent.ts

@@ -1,52 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import type { BooleanField } from "../../../customtypes"
-import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx"
-import { hasContentType } from "../../utils"
-
-export const BooleanContentType = "BooleanContent"
-export const isBooleanContent = (u: unknown): u is BooleanContent =>
-	hasContentType(u) && u.__TYPE__ === BooleanContentType
-
-type BooleanLegacy = boolean
-
-export const BooleanLegacy = (ctx: LegacyContentCtx) =>
-	new t.Type<BooleanContent, WithTypes<BooleanLegacy>, unknown>(
-		"BooleanLegacy",
-		isBooleanContent,
-		(u) => {
-			return pipe(
-				t.boolean.decode(u),
-				either.map((b) =>
-					BooleanContent.encode({ value: b, __TYPE__: BooleanContentType }),
-				),
-			)
-		},
-
-		(b: BooleanContent) => {
-			return {
-				content: b.value,
-				types: { [ctx.keyOfType]: "Boolean" },
-				keys: {},
-			}
-		},
-	)
-
-export const BooleanContent = t.strict({
-	__TYPE__: t.literal(BooleanContentType),
-	value: t.boolean,
-})
-
-export type BooleanContent = t.TypeOf<typeof BooleanContent>
-
-export const BooleanContentDefaultValue = (
-	field: BooleanField,
-): BooleanContent | undefined =>
-	field.config?.default_value !== undefined
-		? {
-				__TYPE__: BooleanContentType,
-				value: field.config.default_value || false,
-		  }
-		: undefined

package/src/content/fields/nestable/EmbedContent.ts

@@ -1,74 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import { NumberOrNull, StringOrNull } from "../../../validators"
-import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx"
-import { hasContentType } from "../../utils"
-
-export const EmbedContentType = "EmbedContent"
-
-export const isEmbedContent = (u: unknown): u is EmbedContent =>
-	hasContentType(u) && u.__TYPE__ === EmbedContentType
-
-export const EmbedContentLegacy = t.exact(
-	t.intersection([
-		t.type({
-			embed_url: t.string,
-			type: t.string,
-		}),
-		t.partial({
-			version: t.union([t.string, t.number, t.null]),
-			title: StringOrNull,
-			author_name: StringOrNull,
-			author_url: StringOrNull,
-			provider_name: StringOrNull,
-			provider_url: StringOrNull,
-			cache_age: t.union([t.string, t.number, t.null]),
-			thumbnail_url: StringOrNull,
-			thumbnail_width: NumberOrNull,
-			thumbnail_height: NumberOrNull,
-			html: StringOrNull,
-		}),
-	]),
-)
-
-export type EmbedLegacy = t.TypeOf<typeof EmbedContentLegacy>
-
-export const EmbedLegacy = (ctx: LegacyContentCtx) =>
-	new t.Type<EmbedContent, WithTypes<unknown>, unknown>(
-		"EmbedLegacy",
-		isEmbedContent,
-		(u) => {
-			return pipe(
-				EmbedContentLegacy.decode(u),
-				either.map((embed) => ({
-					...embed,
-					all: u,
-					__TYPE__: EmbedContentType,
-				})),
-			)
-		},
-
-		(embed: EmbedContent) => {
-			return {
-				/**
-				 *  we cast here because actually in the all property
-				 * we can have extra keys that are never parsed and we don't want to loose them.
-				 **/
-				content: embed.all,
-				types: { [ctx.keyOfType]: "Embed" },
-				keys: {},
-			}
-		},
-	)
-
-export const EmbedContent = t.intersection([
-	EmbedContentLegacy,
-	t.strict({
-		__TYPE__: t.literal(EmbedContentType),
-		all: t.unknown,
-	}),
-])
-
-export type EmbedContent = t.TypeOf<typeof EmbedContent>