@prismicio/types-internal 3.17.0 → 4.0.0-canary.3fe5f1e

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

@@ -1,241 +0,0 @@
-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
-			}
-		},
-	}
-}

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

@@ -1,224 +0,0 @@
-import { 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 { Link, NestableWidget } from "../../../customtypes"
-import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx"
-import {
-	ContentPath,
-	hasContentType,
-	TraverseWidgetContentFn,
-	TraverseWidgetContentWithModelFn,
-} from "../../utils"
-import {
-	isLinkContent,
-	LinkContent,
-	LinkContentLegacy,
-	LinkContentType,
-} from "./LinkContent"
-
-const RepeatableContentType = "RepeatableContent" as const
-
-export const RepeatableContent = t.strict({
-	__TYPE__: t.literal(RepeatableContentType),
-	type: t.literal("Link"),
-	value: t.array(LinkContent),
-})
-
-export type RepeatableContent = t.TypeOf<typeof RepeatableContent>
-
-export const isRepeatableContent = (u: unknown): u is RepeatableContent =>
-	hasContentType(u) && u.__TYPE__ === RepeatableContentType
-
-export const RepeatableLegacy = (
-	ctx: LegacyContentCtx,
-	fieldType: "Link",
-): t.Type<RepeatableContent, WithTypes<Array<unknown>>, unknown> => {
-	return new t.Type<RepeatableContent, WithTypes<Array<unknown>>, unknown>(
-		"RepeatableLegacy",
-		isRepeatableContent,
-		(items) => {
-			const parsed = pipe(
-				t.array(t.unknown).decode(items),
-				either.map((items) => {
-					const parsedItems = items.reduce<Array<LinkContent>>((acc, item) => {
-						let result
-
-						switch (fieldType) {
-							case "Link":
-								result = LinkContentLegacy(ctx).decode(item)
-								break
-						}
-
-						if (!result) return acc
-						if (isLeft(result)) return acc
-
-						return [...acc, result.right]
-					}, [])
-
-					return {
-						value: parsedItems,
-						type: fieldType,
-						__TYPE__: "RepeatableContent" as const,
-					}
-				}),
-			)
-
-			return parsed
-		},
-		(r: RepeatableContent) => {
-			const res = t.array(LinkContent).encode(r.value)
-			const encodedItems = res.reduce<Array<WithTypes<unknown>>>(
-				(acc, item) => {
-					let encoded
-
-					switch (item.__TYPE__) {
-						case LinkContentType:
-							encoded = LinkContentLegacy(ctx).encode(item)
-							break
-					}
-
-					if (!encoded) return acc
-
-					return [...acc, encoded]
-				},
-				[],
-			)
-
-			return {
-				content: encodedItems.map((encodedItem) => encodedItem.content),
-				types: { [ctx.keyOfType]: `Repeatable.${fieldType}` },
-				keys: encodedItems.reduce<Record<string, string>>(
-					(acc, item) => ({ ...acc, ...item.keys }),
-					{},
-				),
-			}
-		},
-	)
-}
-
-export type RepeatableCustomType = Link
-
-export function traverseRepeatableContent({
-	path,
-	key,
-	apiId,
-	model,
-	content,
-}: {
-	path: ContentPath
-	key: string
-	apiId: string
-	content: RepeatableContent
-	model?: NestableWidget | undefined
-}) {
-	return (
-		transform: TraverseWidgetContentFn,
-	): RepeatableContent | undefined => {
-		const items = content.value.reduce<Array<LinkContent>>(
-			(acc, fieldContent, index) => {
-				const itemPath = path.concat([
-					{ key: index.toString(), type: "Widget" },
-				])
-
-				// Content inside repeatable can't be repeatable.
-				const newModel =
-					model?.type === "Link" && model.config
-						? {
-								...model,
-								config: { ...model.config, repeat: false },
-						  }
-						: model
-
-				const transformedField = transform({
-					path: itemPath,
-					key: key,
-					apiId: apiId,
-					model: newModel,
-					content: fieldContent,
-				})
-
-				// Can happen if the transform function returns undefined to filter out a field
-				if (!transformedField) return acc
-
-				// If the transformed field is not a link content, we don't include it
-				if (!isLinkContent(transformedField)) return acc
-
-				return acc.concat(transformedField)
-			},
-			[],
-		)
-
-		return transform({
-			path,
-			key,
-			apiId,
-			model,
-			content: {
-				__TYPE__: content.__TYPE__,
-				type: content.type,
-				value: items,
-			},
-		})
-	}
-}
-
-export function traverseRepeatableContentWithModel({
-	path,
-	key,
-	model,
-	content,
-}: {
-	path: ContentPath
-	key: string
-	model: NestableWidget
-	content: RepeatableContent | undefined
-}): (
-	transform: TraverseWidgetContentWithModelFn,
-) => RepeatableContent | undefined {
-	return (transform) => {
-		const items =
-			content?.value.reduce<Array<LinkContent>>((acc, fieldContent, index) => {
-				const itemPath = path.concat([
-					{ key: index.toString(), type: "Widget" },
-				])
-
-				const newModel =
-					model?.type === "Link" && model.config
-						? {
-								...model,
-								config: { ...model.config, repeat: false },
-						  }
-						: model
-
-				const transformedField = transform({
-					path: itemPath,
-					key: key,
-					apiId: key,
-					model: newModel,
-					content: fieldContent,
-				})
-
-				if (!transformedField) return acc
-
-				if (!isLinkContent(transformedField)) return acc
-
-				return acc.concat(transformedField)
-			}, []) ?? []
-
-		return transform({
-			path,
-			key,
-			apiId: key,
-			model,
-			content: content
-				? {
-						__TYPE__: content.__TYPE__,
-						type: content.type,
-						value: items,
-				  }
-				: undefined,
-		})
-	}
-}

package/src/content/fields/nestable/RichTextContent/Blocks.ts

@@ -1,238 +0,0 @@
-import { 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 { withFallback } from "io-ts-types"
-
-import {
-	RichTextNodeType,
-	RichTextNodeTypeCodec,
-} from "../../../../customtypes/widgets/nestable"
-import { StringOrNull } from "../../../../validators"
-import { nullable, refineType } from "../../../../validators/function"
-import {
-	EmbedContent,
-	EmbedContentLegacy,
-	EmbedContentType,
-	EmbedLegacy,
-} from "../EmbedContent"
-import { ImageContentView } from "../ImageContent"
-import { FilledLink, FilledLinkLegacy } from "../LinkContent"
-
-const linkSpan = (linkCodec: typeof FilledLink | typeof FilledLinkLegacy) =>
-	t.strict({
-		data: linkCodec,
-		start: t.number,
-		end: t.number,
-		type: t.literal(RichTextNodeType.hyperlink),
-	})
-
-const labelSpan = t.strict({
-	data: withFallback(t.string, ""),
-	start: t.number,
-	end: t.number,
-	type: t.literal("label"),
-})
-
-const basicSpan = t.strict({
-	start: t.number,
-	end: t.number,
-	type: t.keyof({
-		[RichTextNodeType.strong]: null,
-		[RichTextNodeType.em]: null,
-		"list-item": null, // legacy case that should not happen, we shouldn't support this in new page builder or migration API
-	}),
-})
-
-export const Span = t.union([linkSpan(FilledLink), labelSpan, basicSpan])
-export type Span = t.TypeOf<typeof Span>
-
-export const SpanLegacy = t.union([
-	linkSpan(FilledLinkLegacy),
-	labelSpan,
-	basicSpan,
-])
-export type SpanLegacy = t.TypeOf<typeof SpanLegacy>
-
-export const ValidatedSpans = <C extends typeof Span | typeof SpanLegacy>(
-	spanCodec: C,
-) => {
-	type S = t.TypeOf<C>
-
-	return new t.Type<S[], S[], unknown>(
-		"ValidatedSpans",
-		(spans): spans is S[] => Array.isArray(spans) && spans.every(spanCodec.is),
-		(spans: unknown, c) => {
-			if (Array.isArray(spans)) {
-				const res = spans
-					.reduce<Array<S>>((acc, maybeSpan) => {
-						const decodedSpan = spanCodec.decode(maybeSpan)
-						if (isLeft(decodedSpan)) return acc
-						return [...acc, decodedSpan.right]
-					}, [])
-					.sort((m1: S, m2: S) => m1.start - m2.start)
-				return t.success(res)
-			} else return t.failure(spans, c)
-		},
-		(m) => {
-			return m.reduce<Array<S>>((acc, meta) => {
-				const encoded = <S>spanCodec.encode(meta)
-				return [...acc, encoded]
-			}, [])
-		},
-	)
-}
-
-// We allow any codec here and let TypeScript infer the resulting codec.
-// Typing it more precisely creates conflicts.
-//
-// Using `t.Mixed` rather than `t.Type<A, O>` causes `data.linkTo` to be
-// typed as `any`. It seems to be an issue with the `nullable` helper.
-const ImageBlockCodec = <A, O>(linkCodec: t.Type<A, O>) =>
-	t.exact(
-		t.intersection([
-			t.type({
-				type: t.literal(RichTextNodeType.image),
-				data: t.intersection([
-					ImageContentView,
-					t.partial({
-						linkTo: nullable(linkCodec),
-					}),
-				]),
-			}),
-			t.partial({
-				label: StringOrNull,
-				direction: StringOrNull,
-			}),
-		]),
-	)
-
-export const ImageBlock = ImageBlockCodec(FilledLink)
-export type ImageBlock = t.TypeOf<typeof ImageBlock>
-
-const ImageBlockLegacy = ImageBlockCodec(FilledLinkLegacy)
-type ImageBlockLegacy = t.TypeOf<typeof ImageBlockLegacy>
-
-export function checkImageBlock(block: Block): block is ImageBlock {
-	return block.type === RichTextNodeType.image
-}
-
-const embedBlockLegacyCodec = t.exact(
-	t.intersection([
-		t.type({
-			type: t.literal(RichTextNodeType.embed),
-			data: t.unknown,
-		}),
-		t.partial({
-			label: StringOrNull,
-			direction: StringOrNull,
-		}),
-	]),
-)
-
-type EmbedBlockLegacy = t.TypeOf<typeof embedBlockLegacyCodec>
-
-const EmbedBlockLegacy = new t.Type<EmbedBlock, EmbedBlockLegacy, unknown>(
-	"EmbedBlockLegacy",
-	(u): u is EmbedBlock => (u as EmbedBlock).type === "embed",
-	(block) =>
-		pipe(
-			embedBlockLegacyCodec.decode(block),
-			either.chain((decodedBlock) => {
-				return either.map<EmbedLegacy, [EmbedBlockLegacy, EmbedLegacy]>(
-					(decodedData: EmbedLegacy) => {
-						return [decodedBlock, decodedData]
-					},
-				)(EmbedContentLegacy.decode(decodedBlock.data))
-			}),
-			either.map(([block, parsedData]) => {
-				return EmbedBlock.encode({
-					...block,
-					data: {
-						...parsedData,
-						__TYPE__: EmbedContentType,
-						all: block.data,
-					},
-				})
-			}),
-		),
-	(embedBlock: EmbedBlock): EmbedBlockLegacy => {
-		return {
-			...embedBlockLegacyCodec.encode(embedBlock),
-			data: EmbedContentLegacy.encode(embedBlock.data),
-		}
-	},
-)
-export const EmbedBlock = t.exact(
-	t.intersection([
-		t.type({
-			type: t.literal(RichTextNodeType.embed),
-			data: EmbedContent,
-		}),
-		t.partial({
-			label: StringOrNull,
-			direction: StringOrNull,
-		}),
-	]),
-)
-export type EmbedBlock = t.TypeOf<typeof EmbedBlock>
-export function checkEmbedBlock(block: Block): block is EmbedBlock {
-	return block.type === RichTextNodeType.embed
-}
-
-const TextBlockCodec = <C extends typeof Span | typeof SpanLegacy>(
-	spanCodec: C,
-) =>
-	t.exact(
-		t.intersection([
-			t.type({
-				type: refineType(
-					RichTextNodeTypeCodec,
-					`string which isn't ${RichTextNodeType.image} ${RichTextNodeType.embed}`,
-					(s) => s !== RichTextNodeType.image && s !== RichTextNodeType.embed,
-				),
-				content: t.intersection([
-					t.type({
-						text: t.string,
-					}),
-					t.partial({
-						spans: ValidatedSpans(spanCodec),
-					}),
-				]),
-			}),
-			t.partial({
-				label: t.string,
-				direction: t.string,
-			}),
-		]),
-	)
-
-/* These Text block will decode codec A and encode from codec B to A */
-export const TextBlock = TextBlockCodec(Span)
-export type TextBlock = t.TypeOf<typeof TextBlock>
-
-export const TextBlockLegacy = TextBlockCodec(SpanLegacy)
-export type TextBlockLegacy = t.TypeOf<typeof TextBlockLegacy>
-
-const legacyBlockCodec = t.union([
-	EmbedBlockLegacy,
-	ImageBlockLegacy,
-	TextBlockLegacy,
-])
-type BlockLegacy = t.TypeOf<typeof legacyBlockCodec>
-
-export const BlockLegacy = new t.Type<Block, BlockLegacy, unknown>(
-	"BlockLegacy",
-	(u): u is Block =>
-		EmbedBlockLegacy.is(u) || ImageBlockLegacy.is(u) || TextBlockLegacy.is(u),
-	(legacyBlock) => legacyBlockCodec.decode(legacyBlock),
-	(block: Block) => {
-		return (() => {
-			if (ImageBlock.is(block)) return ImageBlockLegacy.encode(block)
-			else if (EmbedBlock.is(block)) return EmbedBlockLegacy.encode(block)
-			else return TextBlockLegacy.encode(block)
-		})() as BlockLegacy
-	},
-)
-export const Block = t.union([ImageBlock, EmbedBlock, TextBlock])
-export type Block = t.TypeOf<typeof Block>