@prismicio/types-internal 1.5.2 → 2.0.0-alpha.0

package/src/content/fields/UIDContent.ts

@@ -1,11 +1,41 @@
+import { either } from "fp-ts"
+import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
-import { UIDContentType as type } from "../../documents/widgets/UIDContent"
+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" },
+			}
+		},
+	)
 
 export const UIDContent = t.type({
-	__TYPE__: t.literal(type),
+	__TYPE__: t.literal(UIDContentType),
 	value: t.string,
 })
 
 export type UIDContent = t.TypeOf<typeof UIDContent>
-export const UIDContentType = type

package/src/content/fields/WidgetContent.ts

@@ -0,0 +1,76 @@
+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 WidgetTypes = 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,27 +1,5 @@
-import * as t from "io-ts"
-
-import { GroupContent, GroupContentType } from "./GroupContent"
-import { NestableContent, NestableTypes } from "./nestable"
-import { SlicesContent, SlicesContentType } from "./slices"
-import { UIDContent, UIDContentType } from "./UIDContent"
-
 export * from "./GroupContent"
 export * from "./nestable"
 export * from "./slices"
 export * from "./UIDContent"
-
-export const WidgetContent = t.union([
-	GroupContent,
-	NestableContent,
-	UIDContent,
-	SlicesContent,
-])
-
-export type WidgetContent = t.TypeOf<typeof WidgetContent>
-
-export const WidgetTypes = {
-	...NestableTypes,
-	UID: UIDContentType,
-	Group: GroupContentType,
-	slices: SlicesContentType,
-} as const
+export * from "./WidgetContent"

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

@@ -1,11 +1,40 @@
+import { either } from "fp-ts"
+import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
-import { BooleanContentType as type } from "../../../documents/widgets/nestable/BooleanContent"
+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" },
+			}
+		},
+	)
 
 export const BooleanContent = t.strict({
-	__TYPE__: t.literal(type),
+	__TYPE__: t.literal(BooleanContentType),
 	value: t.boolean,
 })
 
 export type BooleanContent = t.TypeOf<typeof BooleanContent>
-export const BooleanContentType = type

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

@@ -1,17 +1,88 @@
+import { either } from "fp-ts"
+import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
-import {
-	EmbedContentC as EmbedNoType,
-	EmbedContentType as type,
-} from "../../../documents/widgets/nestable/EmbedContent"
+import { withOptionals } from "../../../utils/Objects"
+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<EmbedLegacy>, unknown>(
+		"EmbedLegacy",
+		isEmbedContent,
+		(u) => {
+			return pipe(
+				EmbedContentLegacy.decode(u),
+				either.map((embed) =>
+					EmbedContent.encode({
+						...embed,
+						__TYPE__: EmbedContentType,
+					}),
+				),
+			)
+		},
+
+		(embed: EmbedContent) => {
+			return {
+				content: withOptionals<EmbedLegacy>(
+					{
+						embed_url: embed.embed_url,
+						type: embed.type,
+					},
+					[
+						["author_name", embed.author_name],
+						["author_url", embed.author_url],
+						["cache_age", embed.cache_age],
+						["html", embed.html],
+						["provider_name", embed.provider_name],
+						["provider_url", embed.provider_url],
+						["thumbnail_height", embed.thumbnail_height],
+						["thumbnail_width", embed.thumbnail_width],
+						["thumbnail_url", embed.thumbnail_url],
+						["title", embed.title],
+						["version", embed.version],
+					],
+				),
+				types: { [ctx.keyOfType]: "Embed" },
+			}
+		},
+	)
 
 export const EmbedContent = t.intersection([
-	EmbedNoType,
+	EmbedContentLegacy,
 	t.strict({
-		__TYPE__: t.literal(type),
-		all: t.unknown,
+		__TYPE__: t.literal(EmbedContentType),
 	}),
 ])
 
 export type EmbedContent = t.TypeOf<typeof EmbedContent>
-export const EmbedContentType = type

package/src/content/fields/nestable/FieldContent/ColorContent.ts

@@ -0,0 +1,48 @@
+import { either } from "fp-ts"
+import { pipe } from "fp-ts/lib/function"
+import * as t from "io-ts"
+
+import { ColorFieldType } from "../../../../customtypes/widgets"
+import TrimmedString from "../../../../validators/TrimmedString"
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx"
+import { hasContentType, hasFieldContentType } from "../../../utils"
+import { FieldContentType } from "./common"
+
+export const isColorContent = (u: unknown): u is ColorContent =>
+	hasContentType(u) &&
+	u.__TYPE__ === FieldContentType &&
+	hasFieldContentType(u) &&
+	u.type === "Color"
+
+export const ColorLegacy = (ctx: LegacyContentCtx) =>
+	new t.Type<ColorContent, WithTypes<string>, unknown>(
+		"ColorLegacy",
+		isColorContent,
+		(u) => {
+			return pipe(
+				TrimmedString.decode(u),
+				either.map((f) =>
+					ColorContent.encode({
+						value: f,
+						type: ColorFieldType,
+						__TYPE__: FieldContentType,
+					}),
+				),
+			)
+		},
+
+		(b: ColorContent) => {
+			return {
+				content: b.value,
+				types: { [ctx.keyOfType]: ColorFieldType },
+			}
+		},
+	)
+
+export const ColorContent = t.strict({
+	type: t.literal(ColorFieldType),
+	value: TrimmedString,
+	__TYPE__: t.literal(FieldContentType),
+})
+
+export type ColorContent = t.TypeOf<typeof ColorContent>

package/src/content/fields/nestable/FieldContent/DateContent.ts

@@ -0,0 +1,48 @@
+import { either } from "fp-ts"
+import { pipe } from "fp-ts/lib/function"
+import * as t from "io-ts"
+
+import { DateFieldType } from "../../../../customtypes/widgets"
+import TrimmedString from "../../../../validators/TrimmedString"
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx"
+import { hasContentType, hasFieldContentType } from "../../../utils"
+import { FieldContentType } from "./common"
+
+export const isDateContent = (u: unknown): u is DateContent =>
+	hasContentType(u) &&
+	u.__TYPE__ === FieldContentType &&
+	hasFieldContentType(u) &&
+	u.type === "Date"
+
+export const DateLegacy = (ctx: LegacyContentCtx) =>
+	new t.Type<DateContent, WithTypes<string>, unknown>(
+		"DateLegacy",
+		isDateContent,
+		(u) => {
+			return pipe(
+				TrimmedString.decode(u),
+				either.map((f) =>
+					DateContent.encode({
+						value: f,
+						type: DateFieldType,
+						__TYPE__: FieldContentType,
+					}),
+				),
+			)
+		},
+
+		(b: DateContent) => {
+			return {
+				content: b.value,
+				types: { [ctx.keyOfType]: DateFieldType },
+			}
+		},
+	)
+
+export const DateContent = t.strict({
+	type: t.literal(DateFieldType),
+	value: TrimmedString,
+	__TYPE__: t.literal(FieldContentType),
+})
+
+export type DateContent = t.TypeOf<typeof DateContent>

package/src/content/fields/nestable/FieldContent/NumberContent.ts

@@ -0,0 +1,48 @@
+import { either } from "fp-ts"
+import { pipe } from "fp-ts/lib/function"
+import * as t from "io-ts"
+
+import { NumberFieldType } from "../../../../customtypes/widgets"
+import TrimmedString from "../../../../validators/TrimmedString"
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx"
+import { hasContentType, hasFieldContentType } from "../../../utils"
+import { FieldContentType } from "./common"
+
+export const isNumberContent = (u: unknown): u is NumberContent =>
+	hasContentType(u) &&
+	u.__TYPE__ === FieldContentType &&
+	hasFieldContentType(u) &&
+	u.type === "Number"
+
+export const NumberLegacy = (ctx: LegacyContentCtx) =>
+	new t.Type<NumberContent, WithTypes<string>, unknown>(
+		"NumberLegacy",
+		isNumberContent,
+		(u) => {
+			return pipe(
+				TrimmedString.decode(u),
+				either.map((f) =>
+					NumberContent.encode({
+						value: f,
+						type: NumberFieldType,
+						__TYPE__: FieldContentType,
+					}),
+				),
+			)
+		},
+
+		(b: NumberContent) => {
+			return {
+				content: b.value,
+				types: { [ctx.keyOfType]: NumberFieldType },
+			}
+		},
+	)
+
+export const NumberContent = t.strict({
+	type: t.literal(NumberFieldType),
+	value: TrimmedString,
+	__TYPE__: t.literal(FieldContentType),
+})
+
+export type NumberContent = t.TypeOf<typeof NumberContent>

package/src/content/fields/nestable/FieldContent/RangeContent.ts

@@ -0,0 +1,48 @@
+import { either } from "fp-ts"
+import { pipe } from "fp-ts/lib/function"
+import * as t from "io-ts"
+
+import { RangeFieldType } from "../../../../customtypes/widgets"
+import TrimmedString from "../../../../validators/TrimmedString"
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx"
+import { hasContentType, hasFieldContentType } from "../../../utils"
+import { FieldContentType } from "./common"
+
+export const isRangeContent = (u: unknown): u is RangeContent =>
+	hasContentType(u) &&
+	u.__TYPE__ === FieldContentType &&
+	hasFieldContentType(u) &&
+	u.type === "Range"
+
+export const RangeLegacy = (ctx: LegacyContentCtx) =>
+	new t.Type<RangeContent, WithTypes<string>, unknown>(
+		"RangeLegacy",
+		isRangeContent,
+		(u) => {
+			return pipe(
+				TrimmedString.decode(u),
+				either.map((f) =>
+					RangeContent.encode({
+						value: f,
+						type: RangeFieldType,
+						__TYPE__: FieldContentType,
+					}),
+				),
+			)
+		},
+
+		(b: RangeContent) => {
+			return {
+				content: b.value,
+				types: { [ctx.keyOfType]: RangeFieldType },
+			}
+		},
+	)
+
+export const RangeContent = t.strict({
+	type: t.literal(RangeFieldType),
+	value: TrimmedString,
+	__TYPE__: t.literal(FieldContentType),
+})
+
+export type RangeContent = t.TypeOf<typeof RangeContent>

package/src/content/fields/nestable/FieldContent/SelectContent.ts

@@ -0,0 +1,48 @@
+import { either } from "fp-ts"
+import { pipe } from "fp-ts/lib/function"
+import * as t from "io-ts"
+
+import { SelectFieldType } from "../../../../customtypes/widgets"
+import TrimmedString from "../../../../validators/TrimmedString"
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx"
+import { hasContentType, hasFieldContentType } from "../../../utils"
+import { FieldContentType } from "./common"
+
+export const isSelectContent = (u: unknown): u is SelectContent =>
+	hasContentType(u) &&
+	u.__TYPE__ === FieldContentType &&
+	hasFieldContentType(u) &&
+	u.type === "Select"
+
+export const SelectLegacy = (ctx: LegacyContentCtx) =>
+	new t.Type<SelectContent, WithTypes<string>, unknown>(
+		"SelectLegacy",
+		isSelectContent,
+		(u) => {
+			return pipe(
+				TrimmedString.decode(u),
+				either.map((f) =>
+					SelectContent.encode({
+						value: f,
+						type: SelectFieldType,
+						__TYPE__: FieldContentType,
+					}),
+				),
+			)
+		},
+
+		(b: SelectContent) => {
+			return {
+				content: b.value,
+				types: { [ctx.keyOfType]: SelectFieldType },
+			}
+		},
+	)
+
+export const SelectContent = t.strict({
+	type: t.literal(SelectFieldType),
+	value: TrimmedString,
+	__TYPE__: t.literal(FieldContentType),
+})
+
+export type SelectContent = t.TypeOf<typeof SelectContent>

package/src/content/fields/nestable/FieldContent/TextContent.ts

@@ -0,0 +1,48 @@
+import { either } from "fp-ts"
+import { pipe } from "fp-ts/lib/function"
+import * as t from "io-ts"
+
+import { TextFieldType } from "../../../../customtypes/widgets"
+import TrimmedString from "../../../../validators/TrimmedString"
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx"
+import { hasContentType, hasFieldContentType } from "../../../utils"
+import { FieldContentType } from "./common"
+
+export const isTextContent = (u: unknown): u is TextContent =>
+	hasContentType(u) &&
+	u.__TYPE__ === FieldContentType &&
+	hasFieldContentType(u) &&
+	u.type === "Text"
+
+export const TextLegacy = (ctx: LegacyContentCtx) =>
+	new t.Type<TextContent, WithTypes<string>, unknown>(
+		"TextLegacy",
+		isTextContent,
+		(u) => {
+			return pipe(
+				TrimmedString.decode(u),
+				either.map((f) =>
+					TextContent.encode({
+						value: f,
+						type: TextFieldType,
+						__TYPE__: FieldContentType,
+					}),
+				),
+			)
+		},
+
+		(b: TextContent) => {
+			return {
+				content: b.value,
+				types: { [ctx.keyOfType]: TextFieldType },
+			}
+		},
+	)
+
+export const TextContent = t.strict({
+	type: t.literal(TextFieldType),
+	value: TrimmedString,
+	__TYPE__: t.literal(FieldContentType),
+})
+
+export type TextContent = t.TypeOf<typeof TextContent>

package/src/content/fields/nestable/FieldContent/TimestampContent.ts

@@ -0,0 +1,48 @@
+import { either } from "fp-ts"
+import { pipe } from "fp-ts/lib/function"
+import * as t from "io-ts"
+
+import { TimestampFieldType } from "../../../../customtypes/widgets"
+import TrimmedString from "../../../../validators/TrimmedString"
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx"
+import { hasContentType, hasFieldContentType } from "../../../utils"
+import { FieldContentType } from "./common"
+
+export const isTimestampContent = (u: unknown): u is TimestampContent =>
+	hasContentType(u) &&
+	u.__TYPE__ === FieldContentType &&
+	hasFieldContentType(u) &&
+	u.type === "Timestamp"
+
+export const TimestampLegacy = (ctx: LegacyContentCtx) =>
+	new t.Type<TimestampContent, WithTypes<string>, unknown>(
+		"TimestampLegacy",
+		isTimestampContent,
+		(u) => {
+			return pipe(
+				TrimmedString.decode(u),
+				either.map((f) =>
+					TimestampContent.encode({
+						value: f,
+						type: TimestampFieldType,
+						__TYPE__: FieldContentType,
+					}),
+				),
+			)
+		},
+
+		(b: TimestampContent) => {
+			return {
+				content: b.value,
+				types: { [ctx.keyOfType]: TimestampFieldType },
+			}
+		},
+	)
+
+export const TimestampContent = t.strict({
+	type: t.literal(TimestampFieldType),
+	value: TrimmedString,
+	__TYPE__: t.literal(FieldContentType),
+})
+
+export type TimestampContent = t.TypeOf<typeof TimestampContent>

package/src/content/fields/nestable/FieldContent/common.ts

@@ -0,0 +1 @@
+export const FieldContentType = "FieldContent"

package/src/content/fields/nestable/FieldContent/index.ts

@@ -0,0 +1,40 @@
+import * as t from "io-ts"
+
+import { ColorContent } from "./ColorContent"
+import { DateContent } from "./DateContent"
+import { NumberContent } from "./NumberContent"
+import { RangeContent } from "./RangeContent"
+import { SelectContent } from "./SelectContent"
+import { TextContent } from "./TextContent"
+import { TimestampContent } from "./TimestampContent"
+
+export const FieldType = t.keyof({
+	Text: null,
+	Date: null,
+	Timestamp: null,
+	Color: null,
+	Number: null,
+	Range: null,
+	Select: null,
+})
+export type FieldType = t.TypeOf<typeof FieldType>
+
+export const FieldContent = t.union([
+	DateContent,
+	ColorContent,
+	NumberContent,
+	RangeContent,
+	SelectContent,
+	TextContent,
+	TimestampContent,
+])
+export type FieldContent = t.TypeOf<typeof FieldContent>
+
+export * from "./ColorContent"
+export * from "./common"
+export * from "./DateContent"
+export * from "./NumberContent"
+export * from "./RangeContent"
+export * from "./SelectContent"
+export * from "./TextContent"
+export * from "./TimestampContent"