@prismicio/types-internal 1.5.3 → 2.0.0-alpha.1

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

@@ -1,16 +1,47 @@
+import { either } from "fp-ts"
+import { pipe } from "fp-ts/function"
 import * as t from "io-ts"
 
-import {
-	GeoPointContent as GeoPointNoType,
-	GeoPointContentType as type,
-} from "../../../documents/widgets/nestable/GeoPointContent"
+import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx"
+import { hasContentType } from "../../utils"
+
+export const GeoPointContentType = "GeoPointContent"
+
+export const isGeoPointContent = (u: unknown): u is GeoPointContent =>
+	hasContentType(u) && u.__TYPE__ === GeoPointContentType
+
+const legacyReader = t.strict({
+	position: t.strict({
+		lat: t.number,
+		lng: t.number,
+	}),
+})
+type GeoPointLegacy = t.TypeOf<typeof legacyReader>
+
+export const GeoPointLegacy = (ctx: LegacyContentCtx) =>
+	new t.Type<GeoPointContent, WithTypes<GeoPointLegacy>, unknown>(
+		"GeoPointLegacy",
+		isGeoPointContent,
+		(u) => {
+			return pipe(
+				legacyReader.decode(u),
+				either.map((geo) =>
+					GeoPointContent.encode({ ...geo, __TYPE__: GeoPointContentType }),
+				),
+			)
+		},
+
+		(geo: GeoPointContent) => ({
+			content: { position: geo.position },
+			types: { [ctx.keyOfType]: "GeoPoint" },
+		}),
+	)
 
 export const GeoPointContent = t.intersection([
-	GeoPointNoType,
+	legacyReader,
 	t.strict({
-		__TYPE__: t.literal(type),
+		__TYPE__: t.literal(GeoPointContentType),
 	}),
 ])
 
 export type GeoPointContent = t.TypeOf<typeof GeoPointContent>
-export const GeoPointContentType = type

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

@@ -1,20 +1,100 @@
+import { either } from "fp-ts"
+import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
-import {
-	ImageContent as ImageNoType,
-	ImageContentType as type,
-	ImageContentView as view,
-} from "../../../documents/widgets/nestable/ImageContent"
+import { withOptionals } from "../../../utils/Objects"
+import { NonEmptyStringOrNull, StringOrNull } from "../../../validators"
+import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx"
+import { hasContentType } from "../../utils"
+
+export const ImageContentType = "ImageContent"
+
+export const isImageContent = (u: unknown): u is ImageContent =>
+	hasContentType(u) && u.__TYPE__ === ImageContentType
+
+const originReader = t.exact(
+	t.type({
+		id: t.string,
+		url: t.string,
+		width: t.number,
+		height: t.number,
+	}),
+)
+
+export const ImageContentView = t.exact(
+	t.intersection([
+		t.type({
+			origin: originReader,
+			width: t.number,
+			height: t.number,
+			edit: t.type({
+				zoom: t.number,
+				crop: t.type({
+					x: t.number,
+					y: t.number,
+				}),
+				background: t.string,
+			}),
+		}),
+		t.partial({
+			url: t.string,
+			credits: NonEmptyStringOrNull,
+			alt: NonEmptyStringOrNull,
+			provider: StringOrNull,
+		}),
+	]),
+)
+export type ImageContentView = t.TypeOf<typeof ImageContentView>
+
+const legacyReader = t.intersection([
+	ImageContentView,
+	t.partial({
+		thumbnails: t.record(t.string, ImageContentView),
+	}),
+])
+
+type ImageLegacy = t.TypeOf<typeof legacyReader>
+
+export const ImageLegacy = (ctx: LegacyContentCtx) =>
+	new t.Type<ImageContent, WithTypes<ImageLegacy>, unknown>(
+		"ImageLegacy",
+		isImageContent,
+		(u) => {
+			return pipe(
+				legacyReader.decode(u),
+				either.map((i) =>
+					ImageContent.encode({ ...i, __TYPE__: ImageContentType }),
+				),
+			)
+		},
+
+		(i: ImageContent) => {
+			return {
+				content: withOptionals<ImageLegacy>(
+					{
+						edit: i.edit,
+						height: i.height,
+						origin: i.origin,
+						width: i.width,
+					},
+					[
+						["alt", i.alt],
+						["credits", i.credits],
+						["provider", i.provider],
+						["thumbnails", i.thumbnails],
+						["url", i.url],
+					],
+				),
+				types: { [ctx.keyOfType]: "Image" },
+			}
+		},
+	)
 
 export const ImageContent = t.intersection([
-	ImageNoType,
+	legacyReader,
 	t.strict({
-		__TYPE__: t.literal(type),
+		__TYPE__: t.literal(ImageContentType),
 	}),
 ])
 
 export type ImageContent = t.TypeOf<typeof ImageContent>
-export const ImageContentType = type
-
-export const ImageContentView = view
-export type ImageContentView = view

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

@@ -1,11 +1,50 @@
+import { either } from "fp-ts"
+import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
-import { IntegrationFieldsContentType as type } from "../../../documents/widgets/nestable/IntegrationFieldsContent"
+import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx"
+import { hasContentType } from "../../utils"
+
+export const IntegrationFieldContentType = "IntegrationFieldsContent"
+
+export const isIntegrationFieldContent = (
+	u: unknown,
+): u is IntegrationFieldContent =>
+	hasContentType(u) && u.__TYPE__ === IntegrationFieldContentType
+
+type IntegrationFieldLegacy = string
+
+export const IntegrationFieldLegacy = (ctx: LegacyContentCtx) =>
+	new t.Type<
+		IntegrationFieldContent,
+		WithTypes<IntegrationFieldLegacy>,
+		unknown
+	>(
+		"IntegrationFieldLegacy",
+		isIntegrationFieldContent,
+		(u) => {
+			return pipe(
+				t.string.decode(u),
+				either.map((i) =>
+					IntegrationFieldContent.encode({
+						value: i,
+						__TYPE__: IntegrationFieldContentType,
+					}),
+				),
+			)
+		},
+
+		(i: IntegrationFieldContent) => {
+			return {
+				content: i.value,
+				types: { [ctx.keyOfType]: "IntegrationFields" },
+			}
+		},
+	)
 
 export const IntegrationFieldContent = t.strict({
-	__TYPE__: t.literal(type),
+	__TYPE__: t.literal(IntegrationFieldContentType),
 	value: t.string,
 })
 
 export type IntegrationFieldContent = t.TypeOf<typeof IntegrationFieldContent>
-export const IntegrationFieldsContentType = type

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

@@ -1,80 +1,241 @@
+import { either } from "fp-ts"
+import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 import { withFallback } from "io-ts-types"
 
-import {
-	DocumentLink,
-	DocumentLinkType as dlType,
-} from "../../../documents/widgets/nestable/Link/DocumentLink"
-import {
-	ExternalLink,
-	ExternalLinkType as elType,
-} from "../../../documents/widgets/nestable/Link/ExternalLink"
-import {
-	FileLink,
-	FileLinkType as flType,
-} from "../../../documents/widgets/nestable/Link/FileLink"
-import {
-	ImageLink,
-	ImageLinkType as ilType,
-} from "../../../documents/widgets/nestable/Link/ImageLink"
-import { LinkContentType as lcType } from "../../../documents/widgets/nestable/Link/LinkContent"
+import { NonEmptyString, StringOrNull } from "../../../validators"
+import { nullable } from "../../../validators/function"
+import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx"
+import { hasContentType } from "../../utils"
+
+export const ImageLinkType = "ImageLink"
+
+const imageLinkLegacyCodec = t.exact(
+	t.intersection([
+		t.type({
+			id: t.string,
+			url: t.string,
+			height: t.string,
+			width: t.string,
+			size: t.string,
+			name: t.string,
+			kind: t.string,
+		}),
+		t.partial({
+			date: StringOrNull,
+		}),
+	]),
+)
+type ImageLinkLegacy = t.TypeOf<typeof imageLinkLegacyCodec>
+const ImageLinkLegacy = new t.Type<ImageLinkContent, ImageLinkLegacy, unknown>(
+	"ImageLink",
+	(u): u is ImageLinkContent =>
+		hasContentType(u) && u.__TYPE__ === ImageLinkType,
+	(image) => {
+		return pipe(
+			imageLinkLegacyCodec.decode(image),
+			either.map((parsedImage) => {
+				return ImageLinkContent.encode({
+					...parsedImage,
+					__TYPE__: ImageLinkType,
+				})
+			}),
+		)
+	},
+	(image: ImageLinkContent): ImageLinkLegacy => {
+		return imageLinkLegacyCodec.encode(image)
+	},
+)
 
 export const ImageLinkContent = t.intersection([
 	t.strict({
-		__TYPE__: t.literal(ilType),
+		__TYPE__: t.literal(ImageLinkType),
 	}),
-	ImageLink,
+	imageLinkLegacyCodec,
 ])
 export type ImageLinkContent = t.TypeOf<typeof ImageLinkContent>
-export const ImageLinkType = ilType
 
-export const FileLinkContent = t.intersection([
-	FileLink,
-	t.exact(
+export const FileLinkType = "FileLink"
+
+const fileLinkLegacyCodec = t.exact(
+	t.intersection([
 		t.type({
-			__TYPE__: t.literal(flType),
+			id: t.string,
+			url: t.string,
+			name: t.string,
+			kind: t.string,
+		}),
+		t.partial({
+			date: nullable(t.string),
 			size: withFallback(t.string, "0"),
 		}),
+	]),
+)
+type FileLinkLegacy = t.TypeOf<typeof fileLinkLegacyCodec>
+const FileLinkLegacy = new t.Type<FileLinkContent, FileLinkLegacy>(
+	"FileLink",
+	(u): u is FileLinkContent => hasContentType(u) && u.__TYPE__ === FileLinkType,
+	(file) => {
+		return pipe(
+			fileLinkLegacyCodec.decode(file),
+			either.map((parsedFile) => {
+				return FileLinkContent.encode({
+					...parsedFile,
+					__TYPE__: FileLinkType,
+				})
+			}),
+		)
+	},
+	(file: FileLinkContent): FileLinkLegacy => {
+		return fileLinkLegacyCodec.encode(file)
+	},
+)
+
+export const FileLinkContent = t.intersection([
+	fileLinkLegacyCodec,
+	t.exact(
+		t.intersection([
+			t.type({
+				__TYPE__: t.literal(FileLinkType),
+			}),
+			t.partial({
+				size: withFallback(t.string, "0"),
+			}),
+		]),
 	),
 ])
 export type FileLinkContent = t.TypeOf<typeof FileLinkContent>
-export const FileLinkType = flType
 
+export const DocumentLinkType = "DocumentLink"
+
+const documentLinkLegacyCodec = t.strict({ id: NonEmptyString })
+type DocumentLinkLegacy = t.TypeOf<typeof documentLinkLegacyCodec>
+const DocumentLinkLegacy = new t.Type<DocumentLinkContent, DocumentLinkLegacy>(
+	"DocumentLink",
+	(u): u is DocumentLinkContent =>
+		hasContentType(u) && u.__TYPE__ === DocumentLinkType,
+	(file) => {
+		return pipe(
+			documentLinkLegacyCodec.decode(file),
+			either.map((parsedDoc) => {
+				return DocumentLinkContent.encode({
+					...parsedDoc,
+					__TYPE__: DocumentLinkType,
+				})
+			}),
+		)
+	},
+	(doc: DocumentLinkContent): DocumentLinkLegacy => {
+		return documentLinkLegacyCodec.encode(doc)
+	},
+)
 export const DocumentLinkContent = t.intersection([
 	t.strict({
-		__TYPE__: t.literal(dlType),
+		__TYPE__: t.literal(DocumentLinkType),
 	}),
-	DocumentLink,
+	documentLinkLegacyCodec,
 ])
 export type DocumentLinkContent = t.TypeOf<typeof DocumentLinkContent>
-export const DocumentLinkType = dlType
+
+export const ExternalLinkType = "ExternalLink"
+
+const externalLinkLegacyCodec = t.exact(
+	t.intersection([
+		t.type({
+			url: t.string,
+		}),
+		t.partial({
+			kind: t.literal("web"),
+			target: StringOrNull,
+			preview: nullable(
+				t.partial({
+					title: t.string,
+				}),
+			),
+		}),
+	]),
+)
+
+type ExternalLinkLegacy = t.TypeOf<typeof externalLinkLegacyCodec>
+const ExternalLinkLegacy = new t.Type<ExternalLinkContent, ExternalLinkLegacy>(
+	"ExternalLink",
+	(u): u is ExternalLinkContent =>
+		hasContentType(u) && u.__TYPE__ === ExternalLinkType,
+	(file) => {
+		return pipe(
+			externalLinkLegacyCodec.decode(file),
+			either.map((parsedLink) => {
+				return ExternalLinkContent.encode({
+					...parsedLink,
+					__TYPE__: ExternalLinkType,
+				})
+			}),
+		)
+	},
+	(link: ExternalLinkContent): ExternalLinkLegacy => {
+		return externalLinkLegacyCodec.encode(link)
+	},
+)
 
 export const ExternalLinkContent = t.intersection([
 	t.strict({
-		__TYPE__: t.literal(elType),
+		__TYPE__: t.literal(ExternalLinkType),
 	}),
-	ExternalLink,
+	externalLinkLegacyCodec,
 ])
 export type ExternalLinkContent = t.TypeOf<typeof ExternalLinkContent>
-export const ExternalLinkType = elType
 
+export const LinkContentType = "LinkContent"
+
+export const isLinkContent = (u: unknown): u is LinkContent =>
+	hasContentType(u) && u.__TYPE__ === LinkContentType
+
+export const LinkLegacy = t.union([
+	ImageLinkLegacy,
+	FileLinkLegacy,
+	DocumentLinkLegacy,
+	ExternalLinkLegacy,
+])
+
+type LinkLegacy = t.OutputOf<typeof LinkLegacy>
+
+export const LinkContentLegacy = (ctx: LegacyContentCtx) =>
+	new t.Type<LinkContent, WithTypes<LinkLegacy>, unknown>(
+		"LinkLegacy",
+		isLinkContent,
+		(u) => {
+			return pipe(
+				LinkLegacy.decode(u),
+				either.map((link) =>
+					LinkContent.encode({
+						value: link,
+						__TYPE__: LinkContentType,
+					}),
+				),
+			)
+		},
+
+		(link: LinkContent): WithTypes<LinkLegacy> => {
+			return {
+				content: LinkLegacy.encode(link.value),
+				types: { [ctx.keyOfType]: "Link" },
+			}
+		},
+	)
+
+export const Link = t.union([
+	ImageLinkContent,
+	FileLinkContent,
+	DocumentLinkContent,
+	ExternalLinkContent,
+])
 export const LinkContent = t.strict({
-	__TYPE__: t.literal(lcType),
-	value: t.union([
-		ImageLinkContent,
-		FileLinkContent,
-		DocumentLinkContent,
-		ExternalLinkContent,
-	]),
+	__TYPE__: t.literal(LinkContentType),
+	value: Link,
 })
 
 export type LinkContent = t.TypeOf<typeof LinkContent>
-export const LinkContentType = lcType
-
-export const LinksTypes = {
-	DocumentLink: DocumentLinkType,
-	FileLink: FileLinkType,
-	ExternalLink: ExternalLinkType,
-	ImageLink: ImageLinkType,
-	LinkContent: LinkContentType,
-} as const
+
+export type LinksTypes =
+	| LinkContent["__TYPE__"]
+	| LinkContent["value"]["__TYPE__"]