@prismicio/types-internal/src/content/fields/nestable/NestableContent.ts

Prismic types for Custom Types and Prismic Data

import { isRight } from "fp-ts/lib/Either"
import * as t from "io-ts"

import type { NestableWidget } from "../../../customtypes"
import type { LegacyContentCtx } from "../../LegacyContentCtx"
import { EmptyContent, EmptyLegacy, isEmptyContent } from "../EmptyContent"
import {
	BooleanContent,
	BooleanContentDefaultValue,
	BooleanContentType,
	BooleanLegacy,
	isBooleanContent,
} from "./BooleanContent"
import {
	EmbedContent,
	EmbedContentType,
	EmbedLegacy,
	isEmbedContent,
} from "./EmbedContent"
import {
	ColorContent,
	ColorLegacy,
	DateContent,
	DateLegacy,
	isColorContent,
	isDateContent,
	isNumberContent,
	isRangeContent,
	isSelectContent,
	isTextContent,
	isTimestampContent,
	NumberContent,
	NumberLegacy,
	RangeContent,
	RangeLegacy,
	SelectContent,
	SelectContentDefaultValue,
	SelectLegacy,
	TextContent,
	TextLegacy,
	TimestampContent,
	TimestampLegacy,
} from "./FieldContent"
import { FieldContentType } from "./FieldContent/common"
import {
	GeoPointContent,
	GeoPointContentType,
	GeoPointLegacy,
	isGeoPointContent,
} from "./GeoPointContent"
import {
	ImageContent,
	ImageContentType,
	ImageLegacy,
	isImageContent,
} from "./ImageContent"
import {
	IntegrationFieldContent,
	IntegrationFieldContentType,
	IntegrationFieldLegacy,
	isIntegrationFieldContent,
} from "./IntegrationFieldContent"
import {
	isLinkContent,
	LinkContent,
	LinkContentLegacy,
	LinkContentType,
} from "./LinkContent"
import {
	isRepeatableContent,
	RepeatableContent,
	RepeatableLegacy,
} from "./RepeatableContent"
import {
	isRichTextContent,
	RichTextContent,
	RichTextContentType,
	RichTextLegacy,
} from "./RichTextContent"
import {
	isSeparatorContent,
	SeparatorContent,
	SeparatorContentType,
	SeparatorLegacy,
} from "./SeparatorContent"
import {
	isTableContent,
	TableContent,
	TableContentType,
	TableLegacy,
} from "./TableContent"

export const NestableContent = t.union([
	EmptyContent,
	BooleanContent,
	EmbedContent,
	TextContent,
	TimestampContent,
	SelectContent,
	RangeContent,
	NumberContent,
	DateContent,
	ColorContent,
	GeoPointContent,
	ImageContent,
	IntegrationFieldContent,
	LinkContent,
	RichTextContent,
	SeparatorContent,
	TableContent,
	RepeatableContent,
])
export type NestableContent = t.TypeOf<typeof NestableContent>
export type NestableContentType = NestableContent["__TYPE__"]

export const NestableContentDefaultValue = (
	widgetDef: NestableWidget,
): NestableContent | undefined => {
	switch (widgetDef.type) {
		case "Boolean":
			return BooleanContentDefaultValue(widgetDef)
		case "Select":
			return SelectContentDefaultValue(widgetDef)
		default:
			return undefined
	}
}

export const isNestableContent = (u: unknown): u is NestableContent =>
	isTextContent(u) ||
	isColorContent(u) ||
	isDateContent(u) ||
	isTimestampContent(u) ||
	isNumberContent(u) ||
	isRangeContent(u) ||
	isSelectContent(u) ||
	isGeoPointContent(u) ||
	isRichTextContent(u) ||
	isBooleanContent(u) ||
	isEmbedContent(u) ||
	isImageContent(u) ||
	isIntegrationFieldContent(u) ||
	isLinkContent(u) ||
	isSeparatorContent(u) ||
	isTableContent(u) ||
	isEmptyContent(u) ||
	isRepeatableContent(u)

export const NestableLegacy = (ctx: LegacyContentCtx) => {
	return {
		decode(value: unknown) {
			if (!ctx.fieldType) return

			const nullValue = EmptyLegacy(ctx.fieldType).decode(value)
			if (isRight(nullValue)) return nullValue

			const codec = (() => {
				switch (ctx.fieldType) {
					case "Text":
						return TextLegacy(ctx)
					case "Color":
						return ColorLegacy(ctx)
					case "Date":
						return DateLegacy(ctx)
					case "Timestamp":
						return TimestampLegacy(ctx)
					case "Number":
						return NumberLegacy(ctx)
					case "Range":
						return RangeLegacy(ctx)
					case "Select":
						return SelectLegacy(ctx)
					case "GeoPoint":
						return GeoPointLegacy(ctx)
					case "StructuredText":
						return RichTextLegacy(ctx)
					case "Boolean":
						return BooleanLegacy(ctx)
					case "Embed":
						return EmbedLegacy(ctx)
					case "Image":
						return ImageLegacy(ctx)
					case "IntegrationFields":
						return IntegrationFieldLegacy(ctx)
					case "Link":
						return LinkContentLegacy(ctx)
					case "Separator":
						return SeparatorLegacy(ctx)
					case "Table":
						return TableLegacy(ctx)
					case "Repeatable.Link":
						return RepeatableLegacy(ctx, "Link")
					default:
						return
				}
			})()

			if (!codec) return

			return codec.decode(value)
		},
		encode(value: NestableContent) {
			switch (value.__TYPE__) {
				case FieldContentType: {
					if (value.type === "Text") return TextLegacy(ctx).encode(value)
					if (value.type === "Color") return ColorLegacy(ctx).encode(value)
					if (value.type === "Range") return RangeLegacy(ctx).encode(value)
					if (value.type === "Date") return DateLegacy(ctx).encode(value)
					if (value.type === "Number") return NumberLegacy(ctx).encode(value)
					if (value.type === "Timestamp")
						return TimestampLegacy(ctx).encode(value)
					if (value.type === "Select") return SelectLegacy(ctx).encode(value)
					return
				}
				case GeoPointContentType:
					return GeoPointLegacy(ctx).encode(value)
				case RichTextContentType:
					return RichTextLegacy(ctx).encode(value)
				case EmbedContentType:
					return EmbedLegacy(ctx).encode(value)
				case BooleanContentType:
					return BooleanLegacy(ctx).encode(value)
				case ImageContentType:
					return ImageLegacy(ctx).encode(value)
				case IntegrationFieldContentType:
					return IntegrationFieldLegacy(ctx).encode(value)
				case LinkContentType:
					return LinkContentLegacy(ctx).encode(value)
				case SeparatorContentType:
					return SeparatorLegacy(ctx).encode(value)
				case TableContentType:
					return TableLegacy(ctx).encode(value)
				case "RepeatableContent":
					return RepeatableLegacy(ctx, value.type).encode(value)

				default:
					return
			}
		},
	}
}